import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.codelibs.fess.unit.UnitFessTestCase;

public class DocumentUtilTest extends UnitFessTestCase {

    public void test_string() {
        Map<String, Object> doc = new HashMap<>();

        String expected = "1";
        doc.put("key1", expected);
        assertEquals(expected, DocumentUtil.getValue(doc, "key1", String.class));

        when:
        def result = withEntryPoint(GET_PROPERTY, "testString") {
            [
                instance.metaClass.getProperty(instance, "testString"),
                instance.metaClass.getProperty(instance, "testString")
            ]
        }

        then:
        result == ["testString-intercepted", "testString"]
    }

    def 'intercepts setting #type property #method from closure'() {

		buf.Truncate(20)
		check(t, "TestBasicOperations (8)", &buf, testString[0:20])

		empty(t, "TestBasicOperations (9)", &buf, testString[0:20], make([]byte, 5))
		empty(t, "TestBasicOperations (10)", &buf, "", make([]byte, 100))

		buf.WriteByte(testString[1])
		c, err := buf.ReadByte()
		if want := testString[1]; err != nil || c != want {
			t.Errorf("ReadByte: got (%q, %v), want (%q, %v)", c, err, want, nil)
		}

 * a different class {@link CompositeCallInterceptionTestInterceptorsDeclaration}.
 */
public class CompositeInterceptorTestReceiver {
    public String intercepted = null;
    private String testString = "testString";
    private boolean testFlag = false;

    public void test() {}
    public void test(CompositeInterceptorTestReceiver arg) {}
    public void testVararg(Object... arg) {}

type testString string
type testIntArray [4]int
type testEface any
type testStringArray [3]string
type testStringStruct struct {
	a string
}
type testStringStructArrayStruct struct {
	s [2]testStringStruct
}
type testStruct struct {
	z float64
	b string
}

func TestHandle(t *testing.T) {
	testHandle[testString](t, "foo")
	testHandle[testString](t, "bar")

    public void callNonIntercepted() {
        intercepted = "callNotIntercepted()-not-intercepted";
    }

    private String testString = "testString";

    public String getTestString() {
        return testString;
    }

    public void setTestString(String newValue) {
        testString = newValue;
    }

    private boolean testFlag = false;

    public boolean isTestFlag() {
        return testFlag;
    }

        "normal getter"       | "call site" | "getTestString()"                             | { it.testString }                    | false
        "boolean getter"      | "call site" | "isTestFlag()"                                | { it.testFlag }                      | false

  const absl::Status write_status =
      WriteStringToFile(dst_file_path, "test_string");
  ASSERT_THAT(write_status, IsOk());

  auto* const env = tsl::Env::Default();
  ASSERT_THAT(env->FileExists(dst_file_path), IsOk());

  std::string data{};
  ASSERT_THAT(tsl::ReadFileToString(env, dst_file_path, &data), IsOk());

  EXPECT_THAT(data, Eq("test_string"));
}

TEST(IoTest, ReadFileToString) {

        return new UserAgentMatcher(applicationName, version);
    }

    @Override
    public boolean matches(Object o) {
        String testString = expectedUserAgentString();
        return CoreMatchers.equalTo(testString).matches(o);
    }

    private String expectedUserAgentString() {
        String javaVendor = System.getProperty("java.vendor");

        "normal getter"       | "call site" | "getTestString()"                             | { it.testString }                    | false
        "boolean getter"      | "call site" | "isTestFlag()"                                | { it.testFlag }                      | false