Java example source code file (DefaultStaticTestData.java)

This example Java source code file (DefaultStaticTestData.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

abstract, annotation, default, methoddesc, object, regular, static, string, testif1, testif12, testif2, testif2a, testif2b, testif9, util, yes

The DefaultStaticTestData.java Java example source code

/*
 * Copyright (c) 2013, 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.
 *
 * 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.
 */

/*
 * Test Data used for testing default/static method
 *
 * @author Yong Lu
 */

import java.util.Arrays;
import java.util.List;

import org.testng.annotations.DataProvider;
import org.testng.collections.Lists;

import static helper.Mod.*;
import static helper.Declared.*;
import helper.Mod;
import helper.Declared;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@MethodDesc(name = "defaultMethod", retval = "TestIF1.defaultMethod", mod = DEFAULT, declared = YES)
interface TestIF1 {

    default String defaultMethod() {
        return "TestIF1.defaultMethod";
    }
}

@MethodDesc(name = "defaultMethod", retval = "TestIF1.defaultMethod", mod = DEFAULT, declared = NO)
class TestClass1 implements TestIF1 {
}

@MethodDesc(name = "staticMethod", retval = "TestIF2.staticMethod", mod = STATIC, declared = YES)
interface TestIF2 {

    static String staticMethod() {
        return "TestIF2.staticMethod";
    }
}

@MethodDesc(name = "method", retval = "TestIF2.staticMethod", mod = REGULAR, declared = YES)
class TestClass2 implements TestIF2 {

    public String method() {
        return TestIF2.staticMethod();
    }
}

@MethodDesc(name = "defaultMethod", retval = "TestIF3.defaultMethod", mod = DEFAULT, declared = YES)
@MethodDesc(name = "method", retval = "", mod = ABSTRACT, declared = YES)
interface TestIF3 {

    String method();

    default String defaultMethod() {
        return "TestIF3.defaultMethod";
    }
}

@MethodDesc(name = "defaultMethod", retval = "TestIF3.defaultMethod", mod = DEFAULT, declared = NO)
@MethodDesc(name = "method", retval = "TestClass3.method", mod = REGULAR, declared = YES)
class TestClass3 implements TestIF3 {

    public String method() {
        return "TestClass3.method";
    }
}

@MethodDesc(name = "staticMethod", retval = "TestIF4.staticMethod", mod = STATIC, declared = YES)
@MethodDesc(name = "method", retval = "", mod = ABSTRACT, declared = YES)
interface TestIF4 {

    String method();

    static String staticMethod() {
        return "TestIF4.staticMethod";
    }
}

@MethodDesc(name = "method", retval = "TestClass4.method", mod = REGULAR, declared = YES)
class TestClass4 implements TestIF4 {

    public String method() {
        return "TestClass4.method";
    }
}

@MethodDesc(name = "defaultMethod", retval = "TestIF5.defaultMethod", mod = DEFAULT, declared = YES)
@MethodDesc(name = "staticMethod", retval = "TestIF5.staticMethod", mod = STATIC, declared = YES)
interface TestIF5 {

    default String defaultMethod() {
        return "TestIF5.defaultMethod";
    }

    static String staticMethod() {
        return "TestIF5.staticMethod";
    }
}

@MethodDesc(name = "defaultMethod", retval = "TestIF5.defaultMethod", mod = DEFAULT, declared = NO)
class TestClass5 implements TestIF5 {
}

@MethodDesc(name = "defaultMethod", retval = "TestIF6.defaultMethod", mod = DEFAULT, declared = YES)
@MethodDesc(name = "staticMethod", retval = "TestIF6.staticMethod", mod = STATIC, declared = YES)
@MethodDesc(name = "method", retval = "", mod = ABSTRACT, declared = YES)
interface TestIF6 {

    String method();

    default String defaultMethod() {
        return "TestIF6.defaultMethod";
    }

    static String staticMethod() {
        return "TestIF6.staticMethod";
    }
}

@MethodDesc(name = "defaultMethod", retval = "TestIF6.defaultMethod", mod = DEFAULT, declared = NO)
@MethodDesc(name = "method", retval = "TestClass6.method", mod = REGULAR, declared = YES)
class TestClass6 implements TestIF6 {

    public String method() {
        return "TestClass6.method";
    }
}

@MethodDesc(name = "defaultMethod", retval = "TestIF7.TestClass7", mod = DEFAULT, declared = YES)
interface TestIF7<T> {

    default T defaultMethod(T t) {
        return t;
    }
}

@MethodDesc(name = "defaultMethod", retval = "TestIF7.TestClass7", mod = DEFAULT, declared = NO)
class TestClass7<T> implements TestIF7 {
}

@MethodDesc(name = "defaultMethod", retval = "TestIF8.TestClass8", mod = DEFAULT, declared = YES)
interface TestIF8<E> {

    default <E> E defaultMethod(E e) {
        return e;
    }
}

@MethodDesc(name = "defaultMethod", retval = "TestIF8.TestClass8", mod = DEFAULT, declared = NO)
class TestClass8<T> implements TestIF8 {
}

@MethodDesc(name = "defaultMethod", retval = "TestIF9.defaultMethod", mod = DEFAULT, declared = YES)
interface TestIF9 extends TestIF1 {

    default String defaultMethod() {
        return "TestIF9.defaultMethod";
    }
}

@MethodDesc(name = "defaultMethod", retval = "TestIF9.defaultMethod", mod = DEFAULT, declared = NO)
class TestClass9 implements TestIF9 {
}

@MethodDesc(name = "defaultMethod", retval = "TestIF9.defaultMethod", mod = DEFAULT, declared = NO)
@MethodDesc(name = "method", retval = "TestIF9.defaultMethod", mod = REGULAR, declared = YES)
class TestClass91 implements TestIF9, TestIF1 {

    public String method() {
        return defaultMethod();
    }
}

@MethodDesc(name = "staticMethod", retval = "TestIF10.staticMethod", mod = STATIC, declared = YES)
interface TestIF10 extends TestIF2 {

    static String staticMethod() {

        return "TestIF10.staticMethod";
    }
}

@MethodDesc(name = "staticMethod", retval = "TestIF11.staticMethod", mod = STATIC, declared = YES)
@MethodDesc(name = "defaultMethod", retval = "TestIF1.defaultMethod", mod = DEFAULT, declared = NO)
interface TestIF11 extends TestIF1 {

    static String staticMethod() {
        return "TestIF11.staticMethod";
    }
}

@MethodDesc(name = "defaultMethod", retval = "TestIF1.defaultMethod", mod = DEFAULT, declared = NO)
class TestClass11 implements TestIF11 {
}

@MethodDesc(name = "defaultMethod", retval = "TestIF12.defaultMethod", mod = DEFAULT, declared = YES)
interface TestIF12 extends TestIF2 {

    default String defaultMethod() {
        return "TestIF12.defaultMethod";
    }
}

@MethodDesc(name = "defaultMethod", retval = "TestIF12.defaultMethod", mod = DEFAULT, declared = NO)
class TestClass12 implements TestIF12 {
}

//Diamond Case
@MethodDesc(name = "defaultMethod", retval = "TestIF1.defaultMethod", mod = DEFAULT, declared = NO)
interface TestIF1A extends TestIF1 {
}

@MethodDesc(name = "defaultMethod", retval = "TestIF1.defaultMethod", mod = DEFAULT, declared = NO)
interface TestIF1B extends TestIF1 {
}

@MethodDesc(name = "defaultMethod", retval = "TestIF1.defaultMethod", mod = DEFAULT, declared = NO)
class TestClass13 implements TestIF1A, TestIF1B {
}

//Diamond Override Case
@MethodDesc(name = "defaultMethod", retval = "TestIF1C.defaultMethod", mod = DEFAULT, declared = YES)
interface TestIF1C extends TestIF1 {

    default String defaultMethod() {
        return "TestIF1C.defaultMethod";
    }
}

@MethodDesc(name = "defaultMethod", retval = "TestIF1D.defaultMethod", mod = DEFAULT, declared = YES)
interface TestIF1D extends TestIF1 {

    default String defaultMethod() {
        return "TestIF1D.defaultMethod";
    }
}

@MethodDesc(name = "defaultMethod", retval = "TestClass14.defaultMethod", mod = REGULAR, declared = YES)
class TestClass14 implements TestIF1C, TestIF1D {

    public String defaultMethod() {
        return "TestClass14.defaultMethod";
    }
}

@MethodDesc(name = "defaultMethod", retval = "", mod = ABSTRACT, declared = YES)
interface TestIF15 extends TestIF1 {

    String defaultMethod();
}

@MethodDesc(name = "defaultMethod", retval = "TestClass15.defaultMethod", mod = REGULAR, declared = YES)
class TestClass15 implements TestIF15 {

    public String defaultMethod() {
        return "TestClass15.defaultMethod";
    }
}

interface FuncInterface<T> {

    String test(T t);
}

@MethodDesc(name = "defaultMethod", retval = "TestIF16.defaultMethod", mod = DEFAULT, declared = YES)
interface TestIF16 {

    default String defaultMethod() {
        FuncInterface<Object> fi = o -> o.toString();
        Object o = "TestIF16.defaultMethod";
        return fi.test(o);
    }
}

@MethodDesc(name = "defaultMethod", retval = "TestIF16.defaultMethod", mod = DEFAULT, declared = NO)
class TestClass16 implements TestIF16 {
}

@MethodDesc(name = "defaultMethod", retval = "TestIF17.defaultMethod", mod = DEFAULT, declared = YES)
@MethodDesc(name = "staticMethod", retval = "TestIF17.staticMethod", mod = STATIC, declared = YES)
interface TestIF17 {

    default String defaultMethod() {
        return staticMethod().replace("staticMethod", "defaultMethod");
    }

    public static String staticMethod() {
        return "TestIF17.staticMethod";
    }
}

@MethodDesc(name = "defaultMethod", retval = "TestIF17.defaultMethod", mod = DEFAULT, declared = NO)
class TestClass17 implements TestIF17 {
}


@MethodDesc(name = "defaultMethod", retval = "TestIF17.defaultMethod", mod = DEFAULT, declared = NO)
class TestClass18 extends TestClass17 {
}


@Retention(RetentionPolicy.RUNTIME)
@Repeatable(MethodDescs.class)
@interface MethodDesc {
    String name();
    String retval();
    Mod mod();
    Declared declared();
}

@Retention(RetentionPolicy.RUNTIME)
@interface MethodDescs {
    MethodDesc[] value();
}

//Diamond Case for static method
@MethodDesc(name = "staticMethod", retval = "TestIF2A.staticMethod", mod = STATIC, declared = YES)
interface TestIF2A extends TestIF2 {
    static String staticMethod() {
        return "TestIF2A.staticMethod";
    }
}

@MethodDesc(name = "method", retval = "", mod = ABSTRACT, declared = YES)
interface TestIF2B extends TestIF2 {
    String method();
}

@MethodDesc(name = "method", retval = "", mod = ABSTRACT, declared = YES)
interface TestIF18 extends TestIF10, TestIF2A {
    String method();
}

@MethodDesc(name = "method", retval = "", mod = ABSTRACT, declared = NO)
@MethodDesc(name = "defaultMethod", retval = "TestIF12.defaultMethod", mod = DEFAULT, declared = NO)
interface TestIF19 extends TestIF12, TestIF2B {
}

@MethodDesc(name = "staticMethod", retval = "TestIF20.staticMethod", mod = STATIC, declared = YES)
@MethodDesc(name = "defaultMethod", retval = "TestIF12.defaultMethod", mod = DEFAULT, declared = NO)
interface TestIF20 extends TestIF12, TestIF2A {
    static String staticMethod() {
        return "TestIF20.staticMethod";
    }
}

@MethodDesc(name = "method", retval = "", mod = ABSTRACT, declared = NO)
interface TestIF21 extends TestIF2A, TestIF2B {
}

public class DefaultStaticTestData {

    /**
     * Test data for DefaultStaticInvokeTest The format of inner array is: First
     * data is the name of the class under test Second data used in test as the
     * arguments used for the method call.
     */
    @DataProvider
    static Object[][] testClasses() {
        return new Object[][]{
            {"TestClass1", null},
            {"TestClass2", null},
            {"TestClass3", null},
            {"TestClass4", null},
            {"TestClass5", null},
            {"TestClass6", null},
            {"TestClass7", "TestIF7.TestClass7"},
            {"TestClass8", "TestIF8.TestClass8"},
            {"TestClass9", null},
            {"TestClass91", null},
            {"TestClass11", null},
            {"TestClass12", null},
            {"TestClass13", null},
            {"TestClass14", null},
            {"TestClass15", null},
            {"TestClass16", null},
            {"TestClass17", null},
            {"TestClass18", null},
        };
    }

    /**
     * Test data for DefaultStaticInvokeTest The format of inner array is: First
     * data is the name of the interface under test Second data used in test as
     * the arguments used for the method call.
     */
    @DataProvider
    static Object[][] testInterfaces() {
        return new Object[][]{
            {"TestIF1", null},
            {"TestIF2", null},
            {"TestIF2A", null},
            {"TestIF2B", null},
            {"TestIF3", null},
            {"TestIF4", null},
            {"TestIF5", null},
            {"TestIF6", null},
            {"TestIF7", "TestIF7.TestClass7"},
            {"TestIF8", "TestIF8.TestClass8"},
            {"TestIF9", null},
            {"TestIF10", null},
            {"TestIF11", null},
            {"TestIF12", null},
            {"TestIF1A", null},
            {"TestIF1B", null},
            {"TestIF1C", null},
            {"TestIF1D", null},
            {"TestIF15", null},
            {"TestIF16", null},
            {"TestIF17", null},
            {"TestIF18", null},
            {"TestIF19", null},
            {"TestIF20", null},
            {"TestIF21", null},
        };
    }

    @DataProvider
    static Object[][] testCasesAll() {
        List<Object[]> result = Lists.newArrayList();
        result.addAll(Arrays.asList(testClasses()));
        result.addAll(Arrays.asList(testInterfaces()));
        return result.toArray(new Object[result.size()][]);
    }
}