java - 为 Java 代码定义测试数据 - 简单 - 也许使用 Scala？

Question

是否有可能为 Java 程序定义一些测试数据，使其易于人类阅读并以编程方式解析为相关函数调用和数据元素。如果不可能在 Java 中实现，我愿意为此使用 Scala。被测代码是 java 代码，不会移植到 Scala。

    interface someInterface {
        class X {
            // the member variables will always either 
            // be enums or intrinsic types 
            private int a;
            public int a() { return this.a; };
            public void a(int a) {this.a = a; };

            private double b;
            public double b() { return this.b; };
            public void b(double b) {this.b = b; };

            private String c;
            public String c() { return this.c; };
            public void c(String c) {this.c = c; };
        }

        enum A {
            A_1,
            A_2
        }
        class Y {
            // assume setters and getters as per X above
            private A a;
            private double b;
            private String c;
            private Z[] z;
        }
        class Z {
            private int a;
            private double b;
            private String c;
        }

        Y function1(X x, String s);
    }

    public void boo() {
        String[] testData = {
            /* how can I specify this array so that 
               coo(...) can be called as below
               would I be better off defining this 
               test code in Scala?
               the classes and interfaces above: 
               someInterface, A, X, Y and Z are in Java 
               and will not be ported to Scala */
        };
        coo(testData);
    }

    public void coo(String[] testData) {
        /* this function will know how to:
               a) parse testData
               b) use reflection to call 
                  someInterface.functionXXX with parameters
                  as specified in testData
               c) construct the return result as specified 
                  in testData and compare against actual 
                  return result */
    }   
}

Answer 1

为此，您可以使用 JUnit 4 并使用 Parameterized 类运行。

像这样创建一个测试类:

@RunWith(Parameterized.class)
public class MyTest
{
      private String s;
      private SomeInterface.X x;
      private SomeInterface someInterface;

      @Parameters
      public static Collection<Object[]> prepareData()
      {
            Collection<Object[]> args = new ArrayList<Object[]>();

            args.add(new Object[]{"org.some.thing.Impl",  1, 2.6,"Hello", "World"});
            args.add(new Object[]{"org.some.thing.Impl",  2, 2.7,"Goodbye", "World"});
            args.add(new Object[]{"org.some.thing.Impl",  3, 2.8,"Hello", "Universe"});
            args.add(new Object[]{"org.some.thing.Impl2", 4, 2.9,"Goodbye", "Universe"});

            return args;        
      }

      public MyTest(Object[] args)
      {
            String someInterfaceImplementation = args[0].toString();

            someInterface = null;

            int a = (Integer) args[1];
            double b = (Double) args[2];
            String c = (String) args[3];

            s = (String) args[4];

            x = new SomeInterface.X();
            x.a(a);
            x.b(b);
            x.c(c);
      }

      @Test
      public void testSomething()
      {
            someInterface.function1(x, s);
      }
 }

解释:

@RunWith(Parameterized.class) 告诉 JUnit 框架运行，向测试类询问参数，并使用这些参数运行类中的所有测试。
它需要 Object[] 的 Collection。每个 Object[] 都通过反射传递给此类的构造函数。

prepareData - 提供您要测试的所有场景。

MyTest(Object[] args) 在对特定参数集运行所有测试之前填充此类的成员。重要的是要注意 'someInterface' 只初始化一次 - 对于每个参数集。如果您为同一参数集添加更多测试，您可能需要重新初始化它。

testSomething() 运行您的测试。它将针对 prepareData 提供的每个 Object[] 运行一次。并且它保证在 MyTest(Object[] args) 执行后运行(呃，就像你在这里有任何选择一样)