#

# Copyright (c) 2014, 2019, Oracle and/or its affiliates. All rights reserved.

# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

#

# This code is free software; you can redistribute it and/or modify it

# under the terms of the GNU General Public License version 2 only, as

# published by the Free Software Foundation.  Oracle designates this

# particular file as subject to the "Classpath" exception as provided

# by Oracle in the LICENSE file that accompanied this code.

#

# This code is distributed in the hope that it will be useful, but WITHOUT

# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

# version 2 for more details (a copy is included in the LICENSE file that

# accompanied this code).

#

# You should have received a copy of the GNU General Public License version

# 2 along with this work; if not, write to the Free Software Foundation,

# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

#

# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

# or visit www.oracle.com if you need additional information or have any

# questions.

#

default: all

include $(SPEC)

include MakeBase.gmk

include UtilsForTests.gmk

THIS_FILE := $(TOPDIR)/test/make/TestMakeBase.gmk

DEPS := $(THIS_FILE) \

    $(TOPDIR)/make/common/MakeBase.gmk \

    #

OUTPUT_DIR := $(TESTMAKE_OUTPUTDIR)/make-base

$(call MakeDir, $(OUTPUT_DIR))

################################################################################

# Escape $

ifneq ($(call EscapeDollar, foo$$bar), foo\$$bar)

  $(error EscapeDollar failed $(call EscapeDollar, foo$$bar) foo\$$bar)

endif

ESCAPE_DOLLAR_DIR := $(OUTPUT_DIR)/escape-dollar

$(ESCAPE_DOLLAR_DIR)/_escape_dollar: $(DEPS)

	$(RM) -r $(@D)

	$(MKDIR) -p $(@D)

	$(ECHO) foo\$$bar > $(@D)/file1

	$(ECHO) $(call EscapeDollar, foo$$bar) > $(@D)/file2

	$(ECHO) $(call EscapeDollar, foo\$$bar) > $(@D)/file3

	$(DIFF) $(@D)/file1 $(@D)/file2

	$(DIFF) $(@D)/file1 $(@D)/file3

	$(TOUCH) $@

TEST_TARGETS += $(ESCAPE_DOLLAR_DIR)/_escape_dollar

################################################################################

# Test containing and not-containing

CONT_LIST := foo bar baz foobar foobaz

# Param 1 - string to look for

# Param 2 - expected result

define TestContaining

  value := $$(call containing, $1, $(CONT_LIST))

  ifneq ($$(value), $2)

    $$(info (call containing, $1, $(CONT_LIST)))

    $$(error result >$$(value)<, expected >$2<)

  endif

endef

$(eval $(call TestContaining,bar,bar foobar))

$(eval $(call TestContaining,foo bar,foo bar foobar foobaz))

# Param 1 - string to look for

# Param 2 - expected result

define TestNotContaining

  value := $$(call not-containing, $1, $(CONT_LIST))

  ifneq ($$(value), $2)

    $$(info (call not-containing, $1, $(CONT_LIST)))

    $$(error result >$$(value)<, expected >$2<)

  endif

endef

$(eval $(call TestNotContaining,bar,foo baz foobaz))

$(eval $(call TestNotContaining,foo bar,baz))

################################################################################

# Test Equals

EQUALS_VALUE1 := value1$(SPACE)

EQUALS_VALUE2 := value2

EQUALS_EMPTY :=

ifneq ($(call equals, $(EQUALS_VALUE1), $(EQUALS_VALUE2)), )

  $(error The strings >$(EQUALS_VALUE1)< and >$(EQUALS_VALUE2)< are equal)

endif

ifeq ($(call equals, $(EQUALS_VALUE1), $(EQUALS_VALUE1)), )

  $(error The strings >$(EQUALS_VALUE1)< and >$(EQUALS_VALUE1)< are not equal)

endif

ifeq ($(call equals, $(EQUALS_EMPTY), $(EQUALS_EMPTY)), )

  $(error The strings >$(EQUALS_EMPTY)< and >$(EQUALS_EMPTY)< are not equal)

endif

ifneq ($(call equals, $(EQUALS_EMPTY), $(EQUALS_VALUE2)), )

  $(error The strings >$(EQUALS_EMPTY)< and >$(EQUALS_VALUE2)< are equal)

endif

ifneq ($(call equals, $(EQUALS_VALUE2), $(EQUALS_EMPTY)), )

  $(error The strings >$(EQUALS_VALUE2)< and >$(EQUALS_EMPTY)< are equal)

endif

################################################################################

# Test boolean operators

$(eval $(call assert-equals, $(call And,  true  true  true ), true))

$(eval $(call assert-equals, $(call And,  true  false true ), false))

$(eval $(call assert-equals, $(call And,  false false false ), false))

$(eval $(call assert-equals, $(call And, true), true))

$(eval $(call assert-equals, $(call And, false), false))

$(eval $(call assert-equals, $(call And,    ), true))

$(eval $(call assert-equals, $(call Or,  true  true  true ), true))

$(eval $(call assert-equals, $(call Or,  true  false true ), true))

$(eval $(call assert-equals, $(call Or,  false false false ), false))

$(eval $(call assert-equals, $(call Or, true), true))

$(eval $(call assert-equals, $(call Or, false), false))

$(eval $(call assert-equals, $(call Or,    ), false))

# We cannot catch $(error) while testing, but you can enable this manually

# by uncommenting and watch make fails.

#$(eval $(call assert-equals, $(call And,  non-boolean  ), $(error ...)))

#$(eval $(call assert-equals, $(call Or,  non-boolean  ), $(error ...)))

################################################################################

# Test remove-prefixes

$(call AssertEquals, \

    $(call remove-prefixes, pre, prefix postfix), fix postfix, \

    Prefixes not properly removed)

$(call AssertEquals, \

    $(call remove-prefixes, pre post, prefix postfix), fix fix, \

    Prefixes not properly removed)

################################################################################

# Test ShellQuote

SHELL_QUOTE_VALUE := foo '""' "''" bar

SHELL_QUOTE_RESULT := $(shell $(ECHO) $(call ShellQuote, \

    $(SHELL_QUOTE_VALUE)))

ifneq ($(SHELL_QUOTE_VALUE), $(SHELL_QUOTE_RESULT))

  $(error Expected: >$(SHELL_QUOTE_VALUE)< - Result: >$(SHELL_QUOTE_RESULT)<)

endif

################################################################################

# Test read and write to file

READ_WRITE_FILE := $(OUTPUT_DIR)/read-write

READ_WRITE_VALUE := foo '""' "''" \t\n\\ bar

$(call WriteFile, $(READ_WRITE_VALUE), $(READ_WRITE_FILE))

READ_WRITE_RESULT := $(call ReadFile, $(READ_WRITE_FILE))

ifneq ($(READ_WRITE_VALUE), $(READ_WRITE_RESULT))

  $(error Expected: >$(READ_WRITE_VALUE)< - Result: >$(READ_WRITE_RESULT)<)

endif

################################################################################

# Test creating dependencies on make variables

VARDEP_DIR := $(OUTPUT_DIR)/vardep

VARDEP_SRC_FILE := $(VARDEP_DIR)/src-file

VARDEP_TARGET_FILE := $(VARDEP_DIR)/target-file

VARDEP_FLAG_FILE := $(VARDEP_DIR)/flag-file

$(VARDEP_DIR)/src-file:

	$(MKDIR) -p $(@D)

	$(ECHO) "some string XXX" > $@

$(VARDEP_TARGET_FILE): $(VARDEP_DIR)/src-file \

    $(call DependOnVariable, VARDEP_TEST_VAR)

	$(MKDIR) -p $(@D)

	$(SED) -e 's/XXX/$(VARDEP_TEST_VAR)/g' $< > $@

	$(TOUCH) $(VARDEP_FLAG_FILE)

test-vardep:

	$(RM) $(VARDEP_SRC_FILE) $(VARDEP_TARGET_FILE) $(VARDEP_FLAG_FILE)

        #

        # Simply create the target file and verify that it has the correct value

        #

	$(MAKE) -f $(THIS_FILE) VARDEP_TEST_VAR=value1 $(VARDEP_TARGET_FILE)

	$(PRINTF) "Expecting value1: %s\n" "`$(CAT) $(VARDEP_DIR)/target-file`"

	test "some string value1" = "`$(CAT) $(VARDEP_DIR)/target-file`"

	test -e $(VARDEP_FLAG_FILE)

        #

        # Make the target file again and verify that the value is updated with

        # the new value

        #

	$(SLEEP_ON_MAC)

	$(MAKE) -f $(THIS_FILE) VARDEP_TEST_VAR=value2 $(VARDEP_TARGET_FILE)

	$(PRINTF) "Expecting value2: %s\n" "`$(CAT) $(VARDEP_DIR)/target-file`"

	test "some string value2" = "`$(CAT) $(VARDEP_DIR)/target-file`"

	test -e $(VARDEP_FLAG_FILE)

        #

        # Make the target again with the same value and verify that the recipe

        # was never run by checking that the flag file was not recreated

        #

	$(SLEEP_ON_MAC)

	$(RM) $(VARDEP_FLAG_FILE)

	$(MAKE) -f $(THIS_FILE) VARDEP_TEST_VAR=value2 $(VARDEP_TARGET_FILE)

	$(PRINTF) "Expecting value2: %s\n" "`$(CAT) $(VARDEP_DIR)/target-file`"

	test "some string value2" = "`$(CAT) $(VARDEP_DIR)/target-file`"

	test ! -e $(VARDEP_FLAG_FILE)

        #

        # Test running with spaces at the end and the middle of the value

        # and verify that the file isn't rewritten the second time

        #

	$(MAKE) -f $(THIS_FILE) VARDEP_TEST_VAR="value3  foo " $(VARDEP_TARGET_FILE)

	$(RM) $(VARDEP_FLAG_FILE)

	$(MAKE) -f $(THIS_FILE) VARDEP_TEST_VAR="value3 foo" $(VARDEP_TARGET_FILE)

	test ! -e $(VARDEP_FLAG_FILE)

	$(MAKE) -f $(THIS_FILE) VARDEP_TEST_VAR=" value3  foo" $(VARDEP_TARGET_FILE)

	test ! -e $(VARDEP_FLAG_FILE)

        #

        # Test including some problematic characters

	$(MAKE) -f $(THIS_FILE) VARDEP_TEST_VAR='value4 \$$ORIGIN' $(VARDEP_TARGET_FILE)

	$(RM) $(VARDEP_FLAG_FILE)

	$(MAKE) -f $(THIS_FILE) VARDEP_TEST_VAR='value4 \$$ORIGIN' $(VARDEP_TARGET_FILE)

	test ! -e $(VARDEP_FLAG_FILE)

# Test specifying a specific value file to store variable in

VARDEP_VALUE_FILE := $(VARDEP_DIR)/value-file

VARDEP_TEST_VAR2 := value3

VARDEP_RETURN_VALUE := $(call DependOnVariable, VARDEP_TEST_VAR2, $(VARDEP_VALUE_FILE))

$(call AssertEquals, $(VARDEP_RETURN_VALUE), $(VARDEP_VALUE_FILE), \

    Wrong filename returned)

-include $(VARDEP_VALUE_FILE)

$(call AssertEquals, $(VARDEP_TEST_VAR2_old), $(VARDEP_TEST_VAR2), \

    Wrong contents in vardeps file)

# Test with a variable value containing some problematic characters

VARDEP_TEST_VAR3 := foo '""' "''" bar \$$ORIGIN &\#x00a9

VARDEP_VALUE_FILE := $(call DependOnVariable, VARDEP_TEST_VAR3)

-include $(VARDEP_VALUE_FILE)

$(call AssertEquals, $(call EscapeHash,$(VARDEP_TEST_VAR3_old)), \

    $(call EscapeHash,$(VARDEP_TEST_VAR3)), \

    Wrong contents in vardep file)

TEST_TARGETS += test-vardep

################################################################################

# Test sequence

ifneq ($(call sequence, 1, 1), 1)

  $(error Sequence 1, 1 should be "1", but was $(call sequence, 1, 1))

endif

ifneq ($(call sequence, 2, 3), 2 3)

  $(error Sequence 2, 3 should be "2 3", but was $(call sequence, 2, 3))

endif

ifneq ($(call sequence, 4, 9), 4 5 6 7 8 9)

  $(error Sequence 4, 9 should be "4 5 6 7 8 9", but was $(call sequence, 4, 9))

endif

ifneq ($(call sequence, 5, 15), 5 6 7 8 9 10 11 12 13 14 15)

  $(error Sequence 5, 15 should be "5 6 7 8 9 10 11 12 13 14 15", \

      but was $(call sequence, 5, 15))

endif

################################################################################

# Test that PathList is safe when called multiple nested times.

PATHLIST_INPUT := foo bar baz

$(call AssertEquals, \

    $(call PathList, $(call PathList, $(PATHLIST_INPUT))), \

    $(call PathList, $(PATHLIST_INPUT)), \

    PathList call not safe for calling twice, \

)

################################################################################

# Test FindCommonPathPrefix

$(call AssertEquals, \

    $(call FindCommonPathPrefix, /foo/bar/baz, /foo/bar/banan), \

    /foo/bar, \

    FindCommonPathPrefix, \

)

$(call AssertEquals, \

    $(call FindCommonPathPrefix, /foo/bar/baz, /foo/bar), \

    /foo/bar, \

    FindCommonPathPrefix, \

)

$(call AssertEquals, \

    $(call FindCommonPathPrefix, /foo/bar/baz, /foo/bar/), \

    /foo/bar, \

    FindCommonPathPrefix, \

)

$(call AssertEquals, \

    $(call FindCommonPathPrefix, foo/bar/baz, foo/bar/banan), \

    foo/bar, \

    FindCommonPathPrefix, \

)

$(call AssertEquals, \

    $(call FindCommonPathPrefix, foo/bar/baz, /foo/bar/banan), \

    , \

    FindCommonPathPrefix, \

)

################################################################################

# DirToDotDot

$(call AssertEquals, \

    $(call DirToDotDot, foo/bar/baz/), \

    ../../.., \

    DirToDotDot, \

)

$(call AssertEquals, \

    $(call DirToDotDot, foo/bar), \

    ../.., \

    DirToDotDot, \

)

$(call AssertEquals, \

    $(call DirToDotDot, /foo), \

    .., \

    DirToDotDot, \

)

################################################################################

# RelativePath

$(call AssertEquals, \

    $(call RelativePath, foo/bar/baz, foo/bar/banan), \

    ../baz, \

    RelativePath, \

)

$(call AssertEquals, \

    $(call RelativePath, foo/bar/baz/banan/kung, foo/bar/banan/kung), \

    ../../baz/banan/kung, \

    RelativePath, \

)

$(call AssertEquals, \

    $(call RelativePath, /foo/bar/baz/banan/kung, /foo/bar/banan/kung/), \

    ../../baz/banan/kung, \

    RelativePath, \

)

################################################################################

# Test ParseKeywordVariable

KWBASE := APA=banan;GURKA=tomat;COUNT=1%202%203%204%205;SUM=1+2+3+4+5;MANY_WORDS=I have the best words.

$(eval $(call ParseKeywordVariable, KWBASE, \

    SINGLE_KEYWORDS := APA GURKA SUM, \

    STRING_KEYWORDS := COUNT MANY_WORDS, \

))

$(call AssertEquals, \

    $(KWBASE_APA), \

    banan, \

    ParseKeywordVariable failed to parse APA, \

)

$(call AssertEquals, \

    $(KWBASE_COUNT), \

    1 2 3 4 5, \

    ParseKeywordVariable failed to parse COUNT, \

)

$(call AssertEquals, \

    $(KWBASE_SUM), \

    1+2+3+4+5, \

    ParseKeywordVariable failed to parse SUM, \

)

$(call AssertEquals, \

    $(KWBASE_MANY_WORDS), \

    I have the best words., \

    ParseKeywordVariable failed to parse MANY_WORDS, \

)

# Simulate variable set from command line by using "override"

override KWBASE_WEIRD_GURKA := paprika

KWBASE_WEIRD := ;;APA=banan;;;GURKA=apelsin;APA=skansen;;

$(eval $(call ParseKeywordVariable, KWBASE_WEIRD, \

    SINGLE_KEYWORDS := APA GURKA SUM, \

    STRING_KEYWORDS := COUNT, \

))

$(call AssertEquals, \

    $(KWBASE_WEIRD_APA), \

    skansen, \

    ParseKeywordVariable failed to overwrite APA, \

)

$(call AssertEquals, \

    $(KWBASE_WEIRD_GURKA), \

    paprika, \

    ParseKeywordVariable failed to preserve GURKA, \

)

################################################################################

# Test recursive wildcard

A_FOOBAR := $(OUTPUT_DIR)/wildcard/a/foo.bar

A_B_DOOBAR := $(OUTPUT_DIR)/wildcard/a/b/doo.bar

A_B_FOOBAR := $(OUTPUT_DIR)/wildcard/a/b/foo.bar

A_B_FOOBAZ := $(OUTPUT_DIR)/wildcard/a/b/foo.baz

X_Y_FOOBAR := $(OUTPUT_DIR)/wildcard/x/y/foo.bar

X_Y_FOOBAZ := $(OUTPUT_DIR)/wildcard/x/y/foo.baz

X_Y_FOODOLLAR := $(OUTPUT_DIR)/wildcard/x/y/foo$$foo

$(call MakeDir, $(OUTPUT_DIR)/wildcard/a/b)

$(call MakeDir, $(OUTPUT_DIR)/wildcard/x/y)

$(shell $(TOUCH) $(A_FOOBAR) $(A_B_FOOBAR) $(A_B_DOOBAR) $(A_B_FOOBAZ) \

    $(X_Y_FOOBAR) $(X_Y_FOOBAZ) $(call ShellQuote, $(X_Y_FOODOLLAR)))

ifeq ($(RWILDCARD_WORKS), true)

  $(call AssertEquals, \

      $(sort $(call rwildcard, $(OUTPUT_DIR)/wildcard, *.bar)), \

      $(sort $(A_B_DOOBAR) $(A_B_FOOBAR) $(A_FOOBAR) $(X_Y_FOOBAR)), \

      Wrong files returned from rwildcard, \

  )

  $(call AssertEquals, \

      $(sort $(call rwildcard, $(OUTPUT_DIR)/wildcard, doo.*)), \

      $(A_B_DOOBAR), \

      Wrong files returned from rwildcard, \

  )

  $(call AssertEquals, \

      $(sort $(call rwildcard, $(OUTPUT_DIR)/wildcard, *.bar *.baz)), \

      $(sort $(A_B_DOOBAR) $(A_FOOBAR) $(A_B_FOOBAR) $(A_B_FOOBAZ) \

      $(X_Y_FOOBAR) $(X_Y_FOOBAZ)), \

      Wrong files returned from rwildcard, \

  )

  $(call AssertEquals, \

      $(sort $(call WildcardFindFiles, $(OUTPUT_DIR)/wildcard)), \

      $(sort $(A_B_DOOBAR) $(A_FOOBAR) $(A_B_FOOBAR) $(A_B_FOOBAZ) \

      $(X_Y_FOOBAR) $(X_Y_FOOBAZ) $(X_Y_FOODOLLAR)), \

      Wrong files returned from WildcardFindFiles, \

  )

  $(call AssertEquals, \

      $(sort $(call WildcardFindFiles, $(OUTPUT_DIR)/wildcard/x/y)), \

      $(sort $(X_Y_FOOBAR) $(X_Y_FOOBAZ) $(X_Y_FOODOLLAR)), \

      Wrong files returned from WildcardFindFiles, \

  )

  $(call AssertEquals, \

      $(sort $(call WildcardFindFiles, $(OUTPUT_DIR)/wildcard/a/b $(OUTPUT_DIR)/wildcard/x)), \

      $(sort $(A_B_DOOBAR) $(A_B_FOOBAR) $(A_B_FOOBAZ) \

      $(X_Y_FOOBAR) $(X_Y_FOOBAZ) $(X_Y_FOODOLLAR)), \

      Wrong files returned from WildcardFindFiles, \

  )

endif

$(call AssertEquals, \

    $(sort $(call ShellFindFiles, $(OUTPUT_DIR)/wildcard)), \

    $(sort $(A_B_DOOBAR) $(A_FOOBAR) $(A_B_FOOBAR) $(A_B_FOOBAZ) \

    $(X_Y_FOOBAR) $(X_Y_FOOBAZ) $(X_Y_FOODOLLAR)), \

    Wrong files returned from ShellFindFiles, \

)

$(call AssertEquals, \

    $(sort $(call ShellFindFiles, $(OUTPUT_DIR)/wildcard/x/y)), \

    $(sort $(X_Y_FOOBAR) $(X_Y_FOOBAZ) $(X_Y_FOODOLLAR)), \

    Wrong files returned from ShellFindFiles, \

)

$(call AssertEquals, \

    $(sort $(call ShellFindFiles, $(OUTPUT_DIR)/wildcard/a/b $(OUTPUT_DIR)/wildcard/x)), \

    $(sort $(A_B_DOOBAR) $(A_B_FOOBAR) $(A_B_FOOBAZ) \