Merge "AAPT2: Fix issue with deserializing binary XML" (f74309f5) · Commits · e / os / android_frameworks_base

tools/aapt2/Debug.cpp

+8 −0

Original line number	Diff line number	Diff line
		@@ -450,7 +450,15 @@ class XmlPrinter : public xml::ConstVisitor {
		if (attr.compiled_value != nullptr) {
		attr.compiled_value->PrettyPrint(printer_);
		} else {
		printer_->Print("\"");
		printer_->Print(attr.value);
		printer_->Print("\"");
		}

		if (!attr.value.empty()) {
		printer_->Print(" (Raw: \"");
		printer_->Print(attr.value);
		printer_->Print("\")");
		}
		printer_->Println();
		}

tools/aapt2/cmd/Convert.cpp

+1 −0

Original line number	Diff line number	Diff line
		@@ -139,6 +139,7 @@ class BinaryApkSerializer : public IApkSerializer {
		BigBuffer buffer(4096);
		XmlFlattenerOptions options = {};
		options.use_utf16 = utf16;
		options.keep_raw_values = true;
		XmlFlattener flattener(&buffer, options);
		if (!flattener.Consume(context_, xml)) {
		return false;

tools/aapt2/link/XmlCompatVersioner_test.cpp

+6 −6

Original line number	Diff line number	Diff line
		@@ -23,6 +23,7 @@ using ::aapt::test::ValueEq;
		using ::testing::Eq;
		using ::testing::IsNull;
		using ::testing::NotNull;
		using ::testing::Pointee;
		using ::testing::SizeIs;

		namespace aapt {
		@@ -287,13 +288,13 @@ TEST_F(XmlCompatVersionerTest, DegradeRuleOverridesExistingAttribute) {
		ASSERT_THAT(attr, NotNull());
		ASSERT_THAT(attr->compiled_value, NotNull());
		ASSERT_TRUE(attr->compiled_attribute);
		ASSERT_THAT(*attr->compiled_value, ValueEq(padding_horizontal_value));
		ASSERT_THAT(attr->compiled_value, Pointee(ValueEq(padding_horizontal_value)));

		attr = el->FindAttribute(xml::kSchemaAndroid, "paddingRight");
		ASSERT_THAT(attr, NotNull());
		ASSERT_THAT(attr->compiled_value, NotNull());
		ASSERT_TRUE(attr->compiled_attribute);
		ASSERT_THAT(*attr->compiled_value, ValueEq(padding_horizontal_value));
		ASSERT_THAT(attr->compiled_value, Pointee(ValueEq(padding_horizontal_value)));

		EXPECT_THAT(versioned_docs[1]->file.config.sdkVersion, Eq(SDK_LOLLIPOP_MR1));
		el = versioned_docs[1]->root.get();
		@@ -302,21 +303,20 @@ TEST_F(XmlCompatVersionerTest, DegradeRuleOverridesExistingAttribute) {

		attr = el->FindAttribute(xml::kSchemaAndroid, "paddingHorizontal");
		ASSERT_THAT(attr, NotNull());
		ASSERT_THAT(attr->compiled_value, NotNull());
		ASSERT_TRUE(attr->compiled_attribute);
		ASSERT_THAT(*attr->compiled_value, ValueEq(padding_horizontal_value));
		ASSERT_THAT(attr->compiled_value, Pointee(ValueEq(padding_horizontal_value)));

		attr = el->FindAttribute(xml::kSchemaAndroid, "paddingLeft");
		ASSERT_THAT(attr, NotNull());
		ASSERT_THAT(attr->compiled_value, NotNull());
		ASSERT_TRUE(attr->compiled_attribute);
		ASSERT_THAT(*attr->compiled_value, ValueEq(padding_horizontal_value));
		ASSERT_THAT(attr->compiled_value, Pointee(ValueEq(padding_horizontal_value)));

		attr = el->FindAttribute(xml::kSchemaAndroid, "paddingRight");
		ASSERT_THAT(attr, NotNull());
		ASSERT_THAT(attr->compiled_value, NotNull());
		ASSERT_TRUE(attr->compiled_attribute);
		ASSERT_THAT(*attr->compiled_value, ValueEq(padding_horizontal_value));
		ASSERT_THAT(attr->compiled_value, Pointee(ValueEq(padding_horizontal_value)));
		}

		} // namespace aapt

tools/aapt2/test/Common.h

+44 −71

Original line number	Diff line number	Diff line
		@@ -146,34 +146,10 @@ MATCHER_P(StrEq, a,
		return android::StringPiece16(arg) == a;
		}

		class ValueEq {
		public:
		template <typename arg_type>
		class BaseImpl : public ::testing::MatcherInterface<arg_type> {
		BaseImpl(const BaseImpl&) = default;

		void DescribeTo(::std::ostream* os) const override {
		os << "is equal to " << expected_;
		}

		void DescribeNegationTo(::std::ostream* os) const override {
		os << "is not equal to " << expected_;
		}

		protected:
		BaseImpl(const Value* expected) : expected_(expected) {
		}

		const Value* expected_;
		};

		template <typename T, bool>
		class Impl {};

		template <typename T>
		class Impl<T, false> : public ::testing::MatcherInterface<T> {
		class ValueEqImpl : public ::testing::MatcherInterface<T> {
		public:
		explicit Impl(const Value* expected) : expected_(expected) {
		explicit ValueEqImpl(const Value* expected) : expected_(expected) {
		}

		bool MatchAndExplain(T x, ::testing::MatchResultListener* listener) const override {
		@@ -189,54 +165,51 @@ class ValueEq {
		}

		private:
		DISALLOW_COPY_AND_ASSIGN(Impl);
		DISALLOW_COPY_AND_ASSIGN(ValueEqImpl);

		const Value* expected_;
		};

		template <typename T>
		class Impl<T, true> : public ::testing::MatcherInterface<T> {
		template <typename TValue>
		class ValueEqMatcher {
		public:
		explicit Impl(const Value* expected) : expected_(expected) {
		}

		bool MatchAndExplain(T x, ::testing::MatchResultListener* listener) const override {
		return expected_->Equals(x);
		ValueEqMatcher(TValue expected) : expected_(std::move(expected)) {
		}

		void DescribeTo(::std::ostream* os) const override {
		os << "is equal to " << expected_;
		}

		void DescribeNegationTo(::std::ostream* os) const override {
		os << "is not equal to " << expected_;
		template <typename T>
		operator ::testing::Matcher<T>() const {
		return ::testing::Matcher<T>(new ValueEqImpl<T>(&expected_));
		}

		private:
		DISALLOW_COPY_AND_ASSIGN(Impl);

		const Value* expected_;
		TValue expected_;
		};

		ValueEq(const Value& expected) : expected_(&expected) {
		}
		ValueEq(const Value* expected) : expected_(expected) {
		template <typename TValue>
		class ValueEqPointerMatcher {
		public:
		ValueEqPointerMatcher(const TValue* expected) : expected_(expected) {
		}
		ValueEq(const ValueEq&) = default;

		template <typename T>
		operator ::testing::Matcher<T>() const {
		return ::testing::Matcher<T>(new Impl<T, std::is_pointer<T>::value>(expected_));
		return ::testing::Matcher<T>(new ValueEqImpl<T>(expected_));
		}

		private:
		const Value* expected_;
		const TValue* expected_;
		};

		// MATCHER_P(ValueEq, a,
		// std::string(negation ? "isn't" : "is") + " equal to " + ::testing::PrintToString(a)) {
		// return arg.Equals(&a);
		//}
		template <typename TValue,
		typename = typename std::enable_if<!std::is_pointer<TValue>::value, void>::type>
		inline ValueEqMatcher<TValue> ValueEq(TValue value) {
		return ValueEqMatcher<TValue>(std::move(value));
		}

		template <typename TValue>
		inline ValueEqPointerMatcher<TValue> ValueEq(const TValue* value) {
		return ValueEqPointerMatcher<TValue>(value);
		}

		MATCHER_P(StrValueEq, a,
		std::string(negation ? "isn't" : "is") + " equal to " + ::testing::PrintToString(a)) {

tools/aapt2/xml/XmlDom.cpp

+5 −6

Original line number	Diff line number	Diff line
		@@ -244,14 +244,13 @@ static void CopyAttributes(Element* el, android::ResXMLParser* parser, StringPoo
		str16 = parser->getAttributeStringValue(i, &len);
		if (str16) {
		attr.value = util::Utf16ToUtf8(StringPiece16(str16, len));
		} else {
		}

		android::Res_value res_value;
		if (parser->getAttributeValue(i, &res_value) > 0) {
		attr.compiled_value = ResourceUtils::ParseBinaryResValue(
		ResourceType::kAnim, {}, parser->getStrings(), res_value, out_pool);
		}
		}


		el->attributes.push_back(std::move(attr));
		}