Question

目前，我有一个实现接口的抽象类。所有实现都扩展了抽象类，以实现接口方法的自己实现。

抽象类包含的方法对于每个实现都是相同的。执行方法。我不想为每个实现类都包含相同的“执行”测试。

我可以通过为一个实现类创建一个测试类来成功测试抽象类中的execute方法。问题在于将有更多的类扩展此抽象类，而我不想在每个这些类中编写相同的执行测试。

我想以某种方式在特定的测试类中仅对抽象类的execute方法进行一次测试，因此我只能测试所有其他类的实现逻辑。

Answer 1

您也可以为抽象类创建一个测试类。尽管您不能直接实例化抽象类，但是仍然可以在测试文件中创建一个具体的实现类，仅用于测试抽象类并实现所需的方法。您可以获取一个实例进行测试，例如使用匿名类：

AbstractClassType x = new AbstractClassType() {
    @Override
    public void doSomething() {
        // ...
    }
};

Answer 2

#example data (use 2m rows from postcode centroid file)
df = pandas.read_csv('National_Statistics_Postcode_Lookup_Latest_Centroids.csv', usecols=[0,1], nrows=2000000)
#this will be our grid of points (or lattice) use points from same file for example
df2 = pandas.read_csv('National_Statistics_Postcode_Lookup_Latest_Centroids.csv', usecols=[0,1], nrows=2000)

#reorder lat long columns for balltree input
columnTitles=["Y","X"]
df = df.reindex(columns=columnTitles)
df2 = df2.reindex(columns=columnTitles)

# assign new columns to existing dataframe. attribute will hold the data we want to sum over (set to 1 for now)
df['attribute'] = 1
df2['aggregation'] = 0

RADIANT_TO_KM_CONSTANT = 6367
class BallTreeIndex:
    def __init__(self, lat_longs):
        self.lat_longs = np.radians(lat_longs)
        self.ball_tree_index =BallTree(self.lat_longs, metric='haversine')

    def query_radius(self,query,radius):
        radius_km = radius/1000
        radius_radiant = radius_km / RADIANT_TO_KM_CONSTANT
        query = np.radians(np.array([query]))
        indices = self.ball_tree_index.query_radius(query,r=radius_radiant)
        return indices[0]

#index the base data
a=BallTreeIndex(df.iloc[:,0:2])
#begin to loop over the lattice to test performance
for i in range(0,100):
    b = df2.iloc[i,0:2]
    output = a.query_radius(b, 200)
    accumulation = sum(df.iloc[output, 2])
    df2.iloc[i,2] = accumulation

因此，上述类我可以通过测试BlaBla类来测试execute（）方法。但是将会有更多的类扩展抽象类，我发现将execute（）测试只是随机地放在这些类之一中是很丑陋的。

所以我想要一个用于execute和其他测试类的抽象测试，仅用于测试getDataf.e。

Answer 3

您还可以创建一个参数化的测试类，该类将具有预期结果的实例作为输入并执行测试。（但是，如果您有很多验证逻辑在不同实例之间存在很大差异，@ vlumi创建抽象测试类的方法可能会更好，因为您可以将验证逻辑移到抽象方法中。）

public class MyParameterizedTests {

    @ParameterizedTest
    @MethodSource("getTestData")
    public void test(TestData data) {
        assertEquals(data.expectedResult, data.instance.compute());
    }

    public static TestData[] getTestData() {
        return new TestData[] { new TestData(new X(), "x"), new TestData(new Y(), "y") };
    }
}

class TestData {
    public MyInterface instance;
    public String expectedResult;

    public TestData(MyInterface instance, String expectedResult) {
        this.instance = instance;
        this.expectedResult = expectedResult;
    }
}

interface MyInterface {
    String compute();
}

class X implements MyInterface {

    @Override
    public String compute() {
        return "x";
    }
}

class Y implements MyInterface {

    @Override
    public String compute() {
        return "y";
    }
}

测试抽象类中的方法一次，而不是针对每个实现

3 个答案: