Merge "edify: Move the testcases to gtest." (0bc2df16) · Commits · e / os / android_bootable_recovery

edify/Android.mk

+20 −8

Original line number	Diff line number	Diff line
		# Copyright 2009 The Android Open Source Project
		#
		# Licensed under the Apache License, Version 2.0 (the "License");
		# you may not use this file except in compliance with the License.
		# You may obtain a copy of the License at
		#
		# http://www.apache.org/licenses/LICENSE-2.0
		#
		# Unless required by applicable law or agreed to in writing, software
		# distributed under the License is distributed on an "AS IS" BASIS,
		# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		# See the License for the specific language governing permissions and
		# limitations under the License.

		LOCAL_PATH := $(call my-dir)

		@@ -8,17 +20,17 @@ edify_src_files := \
		expr.cpp

		#
		# Build the host-side command line tool
		# Build the host-side command line tool (host executable)
		#
		include $(CLEAR_VARS)

		LOCAL_SRC_FILES := \
		$(edify_src_files) \
		main.cpp
		edify_parser.cpp

		LOCAL_CFLAGS := -Werror
		LOCAL_CPPFLAGS := -g -O0
		LOCAL_MODULE := edify
		LOCAL_MODULE := edify_parser
		LOCAL_YACCFLAGS := -v
		LOCAL_CPPFLAGS += -Wno-unused-parameter
		LOCAL_CPPFLAGS += -Wno-deprecated-register
		@@ -29,7 +41,7 @@ LOCAL_STATIC_LIBRARIES += libbase
		include $(BUILD_HOST_EXECUTABLE)

		#
		# Build the device-side library
		# Build the device-side library (static library)
		#
		include $(CLEAR_VARS)

edify/main.cpp→edify/edify_parser.cpp

+89 −0

Original line number	Diff line number	Diff line
		@@ -14,153 +14,23 @@
		* limitations under the License.
		*/

		/**
		* This is a host-side tool for validating a given edify script file.
		*
		* We used to have edify test cases here, which have been moved to
		* tests/component/edify_test.cpp.
		*
		* Caveat: It doesn't recognize functions defined through updater, which
		* makes the tool less useful. We should either extend the tool or remove it.
		*/

		#include <stdio.h>
		#include <stdlib.h>
		#include <string.h>

		#include <string>

		#include "expr.h"
		#include "parser.h"

		extern int yyparse(Expr** root, int* error_count);

		int expect(const char* expr_str, const char* expected, int* errors) {
		Expr* e;
		char* result;

		printf(".");

		int error_count = parse_string(expr_str, &e, &error_count);
		if (error_count > 0) {
		printf("error parsing \"%s\" (%d errors)\n",
		expr_str, error_count);
		++*errors;
		return 0;
		}

		State state;
		state.cookie = NULL;
		state.script = strdup(expr_str);
		state.errmsg = NULL;

		result = Evaluate(&state, e);
		free(state.errmsg);
		free(state.script);
		if (result == NULL && expected != NULL) {
		printf("error evaluating \"%s\"\n", expr_str);
		++*errors;
		return 0;
		}

		if (result == NULL && expected == NULL) {
		return 1;
		}

		if (strcmp(result, expected) != 0) {
		printf("evaluating \"%s\": expected \"%s\", got \"%s\"\n",
		expr_str, expected, result);
		++*errors;
		free(result);
		return 0;
		}

		free(result);
		return 1;
		}

		int test() {
		int errors = 0;

		expect("a", "a", &errors);
		expect("\"a\"", "a", &errors);
		expect("\"\\x61\"", "a", &errors);
		expect("# this is a comment\n"
		" a\n"
		" \n",
		"a", &errors);


		// sequence operator
		expect("a; b; c", "c", &errors);

		// string concat operator
		expect("a + b", "ab", &errors);
		expect("a + \n \"b\"", "ab", &errors);
		expect("a + b +\nc\n", "abc", &errors);

		// string concat function
		expect("concat(a, b)", "ab", &errors);
		expect("concat(a,\n \"b\")", "ab", &errors);
		expect("concat(a + b,\nc,\"d\")", "abcd", &errors);
		expect("\"concat\"(a + b,\nc,\"d\")", "abcd", &errors);

		// logical and
		expect("a && b", "b", &errors);
		expect("a && \"\"", "", &errors);
		expect("\"\" && b", "", &errors);
		expect("\"\" && \"\"", "", &errors);
		expect("\"\" && abort()", "", &errors); // test short-circuiting
		expect("t && abort()", NULL, &errors);

		// logical or
		expect("a \|\| b", "a", &errors);
		expect("a \|\| \"\"", "a", &errors);
		expect("\"\" \|\| b", "b", &errors);
		expect("\"\" \|\| \"\"", "", &errors);
		expect("a \|\| abort()", "a", &errors); // test short-circuiting
		expect("\"\" \|\| abort()", NULL, &errors);

		// logical not
		expect("!a", "", &errors);
		expect("! \"\"", "t", &errors);
		expect("!!a", "t", &errors);

		// precedence
		expect("\"\" == \"\" && b", "b", &errors);
		expect("a + b == ab", "t", &errors);
		expect("ab == a + b", "t", &errors);
		expect("a + (b == ab)", "a", &errors);
		expect("(ab == a) + b", "b", &errors);

		// substring function
		expect("is_substring(cad, abracadabra)", "t", &errors);
		expect("is_substring(abrac, abracadabra)", "t", &errors);
		expect("is_substring(dabra, abracadabra)", "t", &errors);
		expect("is_substring(cad, abracxadabra)", "", &errors);
		expect("is_substring(abrac, axbracadabra)", "", &errors);
		expect("is_substring(dabra, abracadabrxa)", "", &errors);

		// ifelse function
		expect("ifelse(t, yes, no)", "yes", &errors);
		expect("ifelse(!t, yes, no)", "no", &errors);
		expect("ifelse(t, yes, abort())", "yes", &errors);
		expect("ifelse(!t, abort(), no)", "no", &errors);

		// if "statements"
		expect("if t then yes else no endif", "yes", &errors);
		expect("if \"\" then yes else no endif", "no", &errors);
		expect("if \"\" then yes endif", "", &errors);
		expect("if \"\"; t then yes endif", "yes", &errors);

		// numeric comparisons
		expect("less_than_int(3, 14)", "t", &errors);
		expect("less_than_int(14, 3)", "", &errors);
		expect("less_than_int(x, 3)", "", &errors);
		expect("less_than_int(3, x)", "", &errors);
		expect("greater_than_int(3, 14)", "", &errors);
		expect("greater_than_int(14, 3)", "t", &errors);
		expect("greater_than_int(x, 3)", "", &errors);
		expect("greater_than_int(3, x)", "", &errors);

		// big string
		expect(std::string(8192, 's').c_str(), std::string(8192, 's').c_str(), &errors);

		printf("\n");

		return errors;
		}

		void ExprDump(int depth, Expr* n, char* script) {
		printf("%s", depth2, "");
		char temp = script[n->end];
		@@ -169,8 +39,7 @@ void ExprDump(int depth, Expr* n, char* script) {
		n->name == NULL ? "(NULL)" : n->name, n->fn, n->start, n->end,
		script+n->start);
		script[n->end] = temp;
		int i;
		for (i = 0; i < n->argc; ++i) {
		for (int i = 0; i < n->argc; ++i) {
		ExprDump(depth+1, n->argv[i], script);
		}
		}
		@@ -179,8 +48,9 @@ int main(int argc, char** argv) {
		RegisterBuiltins();
		FinishRegistration();

		if (argc == 1) {
		return test() != 0;
		if (argc != 2) {
		printf("Usage: %s <edify script>\n", argv[0]);
		return 1;
		}

		FILE* f = fopen(argv[1], "r");

tests/Android.mk

+2 −0

Original line number	Diff line number	Diff line
		@@ -41,11 +41,13 @@ LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk
		LOCAL_MODULE := recovery_component_test
		LOCAL_C_INCLUDES := bootable/recovery
		LOCAL_SRC_FILES := \
		component/edify_test.cpp \
		component/verifier_test.cpp \
		component/applypatch_test.cpp
		LOCAL_FORCE_STATIC_EXECUTABLE := true
		LOCAL_STATIC_LIBRARIES := \
		libapplypatch \
		libedify \
		libotafault \
		libverifier \
		libcrypto_utils \

tests/component/edify_test.cpp

0 → 100644

+156 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2009 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#include <string>

		#include <gtest/gtest.h>

		#include "edify/expr.h"

		static void expect(const char* expr_str, const char* expected) {
		Expr* e;
		int error_count;
		EXPECT_EQ(parse_string(expr_str, &e, &error_count), 0);

		State state;
		state.cookie = nullptr;
		state.errmsg = nullptr;
		state.script = strdup(expr_str);

		char* result = Evaluate(&state, e);

		if (expected == nullptr) {
		EXPECT_EQ(result, nullptr);
		} else {
		EXPECT_STREQ(result, expected);
		}

		free(state.errmsg);
		free(state.script);
		free(result);
		}

		class EdifyTest : public ::testing::Test {
		protected:
		virtual void SetUp() {
		RegisterBuiltins();
		FinishRegistration();
		}
		};

		TEST_F(EdifyTest, parsing) {
		expect("a", "a");
		expect("\"a\"", "a");
		expect("\"\\x61\"", "a");
		expect("# this is a comment\n"
		" a\n"
		" \n",
		"a");
		}

		TEST_F(EdifyTest, sequence) {
		// sequence operator
		expect("a; b; c", "c");
		}

		TEST_F(EdifyTest, concat) {
		// string concat operator
		expect("a + b", "ab");
		expect("a + \n \"b\"", "ab");
		expect("a + b +\nc\n", "abc");

		// string concat function
		expect("concat(a, b)", "ab");
		expect("concat(a,\n \"b\")", "ab");
		expect("concat(a + b,\nc,\"d\")", "abcd");
		expect("\"concat\"(a + b,\nc,\"d\")", "abcd");
		}

		TEST_F(EdifyTest, logical) {
		// logical and
		expect("a && b", "b");
		expect("a && \"\"", "");
		expect("\"\" && b", "");
		expect("\"\" && \"\"", "");
		expect("\"\" && abort()", ""); // test short-circuiting
		expect("t && abort()", nullptr);

		// logical or
		expect("a \|\| b", "a");
		expect("a \|\| \"\"", "a");
		expect("\"\" \|\| b", "b");
		expect("\"\" \|\| \"\"", "");
		expect("a \|\| abort()", "a"); // test short-circuiting
		expect("\"\" \|\| abort()", NULL);

		// logical not
		expect("!a", "");
		expect("! \"\"", "t");
		expect("!!a", "t");
		}

		TEST_F(EdifyTest, precedence) {
		// precedence
		expect("\"\" == \"\" && b", "b");
		expect("a + b == ab", "t");
		expect("ab == a + b", "t");
		expect("a + (b == ab)", "a");
		expect("(ab == a) + b", "b");
		}

		TEST_F(EdifyTest, substring) {
		// substring function
		expect("is_substring(cad, abracadabra)", "t");
		expect("is_substring(abrac, abracadabra)", "t");
		expect("is_substring(dabra, abracadabra)", "t");
		expect("is_substring(cad, abracxadabra)", "");
		expect("is_substring(abrac, axbracadabra)", "");
		expect("is_substring(dabra, abracadabrxa)", "");
		}

		TEST_F(EdifyTest, ifelse) {
		// ifelse function
		expect("ifelse(t, yes, no)", "yes");
		expect("ifelse(!t, yes, no)", "no");
		expect("ifelse(t, yes, abort())", "yes");
		expect("ifelse(!t, abort(), no)", "no");
		}

		TEST_F(EdifyTest, if_statement) {
		// if "statements"
		expect("if t then yes else no endif", "yes");
		expect("if \"\" then yes else no endif", "no");
		expect("if \"\" then yes endif", "");
		expect("if \"\"; t then yes endif", "yes");
		}

		TEST_F(EdifyTest, comparison) {
		// numeric comparisons
		expect("less_than_int(3, 14)", "t");
		expect("less_than_int(14, 3)", "");
		expect("less_than_int(x, 3)", "");
		expect("less_than_int(3, x)", "");
		expect("greater_than_int(3, 14)", "");
		expect("greater_than_int(14, 3)", "t");
		expect("greater_than_int(x, 3)", "");
		expect("greater_than_int(3, x)", "");
		}

		TEST_F(EdifyTest, big_string) {
		// big string
		expect(std::string(8192, 's').c_str(), std::string(8192, 's').c_str());
		}