CoCalc -- JniArmHFTestGenerator.java.txt

GitHub Repository: PojavLauncherTeam/mobile
Path: blob/master/test/hotspot/jtreg/vmTestbase/vm/jit/LongTransitions/JniArmHFTestGenerator.java.txt
⁴¹¹⁵⁹ views
1
/*
2
 * Copyright (c) 2012, 2020, Oracle and/or its affiliates. All rights reserved.
3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4
 *
5
 * This code is free software; you can redistribute it and/or modify it
6
 * under the terms of the GNU General Public License version 2 only, as
7
 * published by the Free Software Foundation.
8
 *
9
 * This code is distributed in the hope that it will be useful, but WITHOUT
10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12
 * version 2 for more details (a copy is included in the LICENSE file that
13
 * accompanied this code).
14
 *
15
 * You should have received a copy of the GNU General Public License version
16
 * 2 along with this work; if not, write to the Free Software Foundation,
17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18
 *
19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20
 * or visit www.oracle.com if you need additional information or have any
21
 * questions.
22
 */
23

24
/* This code generate an LTTest.java and LTTest.c files with corresponding *.cfg files which containt test defenition
25
 * for JNI testing.
26
 *
27
 */
28
import java.io.File;
29
import java.io.FileWriter;
30
import java.io.IOException;
31
import java.util.ArrayList;
32
import java.util.Arrays;
33
import java.util.Random;
34

35
//Java and C file generator for JNI tests
36
public class JniArmHFTestGenerator {
37

38
    private final String JAVA_CLASS_NAME = "LTTest";
39
    private final String C_FNC_NAME_PREFIX = "Java_vm_jit_LongTransitions_" + JAVA_CLASS_NAME + "_";
40
    private final String JAVA_PACKAGE_NAME = "vm.jit.LongTransitions";
41
    private final String TEST_LIST_PREFIX = "vm/jit/LongTransitions";
42
    private final String TEST_LIST_NAME = "vm.jit.long.testlist";
43
    //Maximal line length for some SRC generation function
44
    private final int LINE_LENGTH = 70;
45
    //127 is maximal value for JAVA parameters list
46
    private final int PARAMS_COUNTER = 127;
47
    StringBuilder javaFileSrc;
48
    StringBuilder cFileSrc;
49
    //StringBuilder cfgFileSrc;
50
    private String javaTxtFileName;
51
    private String cTxtFileName;
52
    private File outputDir;
53
    private ArrayList<String> javaFncNames = new ArrayList<String>();
54

55
    public static void main(String[] args) throws IOException {
56
        new JniArmHFTestGenerator().makeSomeTest();
57
    }
58

59
    public void makeSomeTest() throws IOException {
60

61
        makeJavaIntro(JAVA_CLASS_NAME);
62
        makeCIntro();
63
        int cnt = PARAMS_COUNTER;
64

65
        makeOneTest(cnt, ParamType.EASY_F, TestType.RANDOM, "nativeFnc1");
66
        makeOneTest(cnt, ParamType.EASY_D, TestType.RANDOM, "nativeFnc2");
67
        makeOneTest(cnt, ParamType.MIXED_FI1, TestType.RANDOM, "nativeFnc3");
68
        makeOneTest(cnt, ParamType.MIXED_FB1, TestType.RANDOM, "nativeFnc4");
69
        makeOneTest(cnt, ParamType.MIXED_FBI1, TestType.RANDOM, "nativeFnc5");
70
        makeOneTest(cnt, ParamType.MIXED_DI1, TestType.RANDOM, "nativeFnc6");
71
        makeOneTest(cnt, ParamType.MIXED_DB1, TestType.RANDOM, "nativeFnc7");
72
        makeOneTest(cnt, ParamType.MIXED_DBI1, TestType.RANDOM, "nativeFnc8");
73
        makeOneTest(cnt, ParamType.MIXED_DFBI1, TestType.RANDOM, "nativeFnc9");
74
        makeOneTest(cnt, ParamType.MIXED_DF1, TestType.RANDOM, "nativeFnc10");
75
        makeOneTest(cnt, ParamType.MIXED_DFI1, TestType.RANDOM, "nativeFnc11");
76
        makeOneTest(cnt, ParamType.MIXED_DFB1, TestType.RANDOM, "nativeFnc12");
77

78
        makeOneTest(cnt, ParamType.MIXED_FI2, TestType.RANDOM, "nativeFnc13");
79
        makeOneTest(cnt, ParamType.MIXED_FB2, TestType.RANDOM, "nativeFnc14");
80
        makeOneTest(cnt, ParamType.MIXED_FBI2, TestType.RANDOM, "nativeFnc15");
81
        makeOneTest(cnt, ParamType.MIXED_DI2, TestType.RANDOM, "nativeFnc16");
82
        makeOneTest(cnt, ParamType.MIXED_DB2, TestType.RANDOM, "nativeFnc17");
83
        makeOneTest(cnt, ParamType.MIXED_DBI2, TestType.RANDOM, "nativeFnc18");
84
        makeOneTest(cnt, ParamType.MIXED_DFBI2, TestType.RANDOM, "nativeFnc19");
85
        makeOneTest(cnt, ParamType.MIXED_DF2, TestType.RANDOM, "nativeFnc20");
86
        makeOneTest(cnt, ParamType.MIXED_DFI2, TestType.RANDOM, "nativeFnc21");
87
        makeOneTest(cnt, ParamType.MIXED_DFB2, TestType.RANDOM, "nativeFnc22");
88

89
        makeOneTest(cnt, ParamType.MIXED_FI3, TestType.RANDOM, "nativeFnc23");
90
        makeOneTest(cnt, ParamType.MIXED_FB3, TestType.RANDOM, "nativeFnc24");
91
        makeOneTest(cnt, ParamType.MIXED_FBI3, TestType.RANDOM, "nativeFnc25");
92
        makeOneTest(cnt, ParamType.MIXED_DI3, TestType.RANDOM, "nativeFnc26");
93
        makeOneTest(cnt, ParamType.MIXED_DB3, TestType.RANDOM, "nativeFnc27");
94
        makeOneTest(cnt, ParamType.MIXED_DBI3, TestType.RANDOM, "nativeFnc28");
95
        makeOneTest(cnt, ParamType.MIXED_DFBI3, TestType.RANDOM, "nativeFnc29");
96
        makeOneTest(cnt, ParamType.MIXED_DF3, TestType.RANDOM, "nativeFnc30");
97
        makeOneTest(cnt, ParamType.MIXED_DFI3, TestType.RANDOM, "nativeFnc31");
98
        makeOneTest(cnt, ParamType.MIXED_DFB3, TestType.RANDOM, "nativeFnc32");
99

100
        makeOneTest(cnt, ParamType.MIXED_FI4, TestType.RANDOM, "nativeFnc33");
101
        makeOneTest(cnt, ParamType.MIXED_FB4, TestType.RANDOM, "nativeFnc34");
102
        makeOneTest(cnt, ParamType.MIXED_FBI4, TestType.RANDOM, "nativeFnc35");
103
        makeOneTest(cnt, ParamType.MIXED_DI4, TestType.RANDOM, "nativeFnc36");
104
        makeOneTest(cnt, ParamType.MIXED_DB4, TestType.RANDOM, "nativeFnc37");
105
        makeOneTest(cnt, ParamType.MIXED_DBI4, TestType.RANDOM, "nativeFnc38");
106
        makeOneTest(cnt, ParamType.MIXED_DFBI4, TestType.RANDOM, "nativeFnc39");
107
        makeOneTest(cnt, ParamType.MIXED_DF4, TestType.RANDOM, "nativeFnc40");
108
        makeOneTest(cnt, ParamType.MIXED_DFI4, TestType.RANDOM, "nativeFnc41");
109
        makeOneTest(cnt, ParamType.MIXED_DFB4, TestType.RANDOM, "nativeFnc42");
110

111
        makeOneTest(cnt, ParamType.MIXED_FI5, TestType.RANDOM, "nativeFnc43");
112
        makeOneTest(cnt, ParamType.MIXED_FB5, TestType.RANDOM, "nativeFnc44");
113
        makeOneTest(cnt, ParamType.MIXED_FBI5, TestType.RANDOM, "nativeFnc45");
114
        makeOneTest(cnt, ParamType.MIXED_DI5, TestType.RANDOM, "nativeFnc46");
115
        makeOneTest(cnt, ParamType.MIXED_DB5, TestType.RANDOM, "nativeFnc47");
116
        makeOneTest(cnt, ParamType.MIXED_DBI5, TestType.RANDOM, "nativeFnc48");
117
        makeOneTest(cnt, ParamType.MIXED_DFBI5, TestType.RANDOM, "nativeFnc49");
118
        makeOneTest(cnt, ParamType.MIXED_DF5, TestType.RANDOM, "nativeFnc50");
119
        makeOneTest(cnt, ParamType.MIXED_DFI5, TestType.RANDOM, "nativeFnc51");
120
        makeOneTest(cnt, ParamType.MIXED_DFB5, TestType.RANDOM, "nativeFnc52");
121
        makeJavaInvoke();
122
        makeJavaOutro();
123

124
        writeToJavaFile(JAVA_CLASS_NAME);
125
        writeToCFile(JAVA_CLASS_NAME);
126
        //writeCmpFile();
127

128
        writeTestListFile();
129
        writeCfgFile();
130
    }
131

132
    private void makeJavaInvoke() {
133
        appendToJava("    public static void main(String[] args) throws Exception");
134
        appendToJava("    {");
135
        appendToJava("        if ( System.getProperty(\"os.name\").matches(\".*[Ww][Ii][Nn].*\") )");
136
        appendToJava("        {");
137
        appendToJava("            System.out.println(\"TEST PASSED! Dummy execution on Windows* OS!\");");
138
        appendToJava("            return;");
139
        appendToJava("        }");
140

141
        appendToJava("        deleteFiles();");
142
        appendToJavaN("        PrintStream ps=new PrintStream(new File(\"");
143
        appendToJavaN(javaTxtFileName);
144
        appendToJava("\"));");
145

146
        appendToJava("    if (args.length>0)");
147
        appendToJava("        switch(args[0])");
148
        appendToJava("        {");
149

150
        for (String s : javaFncNames) {
151
            appendToJava("        case \"" + s + "\":");
152
            appendToJavaN("            ");
153
            appendToJavaN(s);
154
            appendToJava("_invoke(ps);");
155
            appendToJava("            break;");
156

157
        }
158
        appendToJava("        default:");
159
        appendToJava("            throw new Exception(\"FAIL: invalid args!\");");
160
        appendToJava("        }");
161
        appendToJava("        else");
162
        appendToJava("        {");
163
        appendToJava("            throw new Exception(\"FAIL: invalid args!\");");
164
        appendToJava("        }");
165

166

167
    }
168

169
    private void makeCIntro() {
170
        //appendToC(" //------------------------C----------------------------");
171
        //appendToC("#include \""+className+".h\"");
172
        appendToC("#include <jni.h>");
173
        appendToC("#include <stdio.h>");
174
    }
175

176
    private void makeJavaIntro(String className) {
177

178
        cFileSrc = new StringBuilder();
179
        javaFileSrc = new StringBuilder();
180

181

182
        File outputDirL1 = new File("vm" + File.separatorChar + "jit" + File.separatorChar + "LongTransitions");
183
        //outputDir=new File(outputDirL1,className);
184
        outputDir = outputDirL1;
185
        outputDir.mkdirs();
186

187
        javaTxtFileName = className + "_java.txt";
188
        cTxtFileName = className + "_c.txt";
189

190
        appendToJava("package " + JAVA_PACKAGE_NAME + ";");
191
        appendToJava("import java.io.*;");
192
        appendToJava("import java.util.Random;");
193
        appendToJava("import jdk.test.lib.Utils;");
194
        appendToJava("public class " + className);
195
        appendToJava("{");
196
        appendToJava("    public static boolean flag = false;");
197
        appendToJava("    static Random rnd;");
198
        appendToJava("    static{");
199
        appendToJava("        rnd=Utils.getRandomInstance();");
200
        appendToJava("        System.loadLibrary(\"" + className + "\");");
201
        appendToJava("    }");
202
        //Different randoms
203
        appendToJava("    public static int getRndInt(){return rnd.nextInt(Integer.MAX_VALUE);}");
204
        appendToJava("    public static float getRndFloat(){return rnd.nextFloat()*Float.MAX_VALUE;}");
205
        appendToJava("    public static double getRndDouble(){return rnd.nextDouble()*Double.MAX_VALUE;}");
206
        appendToJava("    public static byte getRndByte(){return (byte)rnd.nextInt(Byte.MAX_VALUE);}");
207

208
        //deleteFiles method
209
        appendToJava("    private static void deleteFiles()");
210
        appendToJava("    {");
211
        appendToJavaN("        File f=new File(\"");
212
        appendToJavaN(javaTxtFileName);
213
        appendToJava("\");");
214
        appendToJava("        if ( f.exists())");
215
        appendToJava("        f.delete();");
216
        appendToJavaN("        f=new File(\"");
217
        appendToJavaN(cTxtFileName);
218
        appendToJava("\");");
219
        appendToJava("        if ( f.exists())");
220
        appendToJava("         f.delete();");
221
        appendToJava("    }");
222
    }
223

224
    private void makeJavaOutro() {
225
        appendToJava("        flag=chkFile();");
226
        appendToJava("        if(!flag)");
227
        appendToJava("            throw new Exception(\"FAIL:Tests failed!\"); ");
228
        appendToJava("    }");
229
        appendToJava("    private static boolean chkFile()");
230
        appendToJava("    {");
231
        appendToJava("        File javaFile=new File(\"" + javaTxtFileName + "\");");
232
        appendToJava("        if (! javaFile.exists())");
233
        appendToJava("        {");
234
        appendToJava("            System.out.println(\"FAIL:Failed to open file " + javaTxtFileName + " - file not exists!\");");
235
        appendToJava("            return false;");
236
        appendToJava("        }");
237
        appendToJava("        File cFile=new File(\"" + cTxtFileName + "\");");
238
        appendToJava("        if (! cFile.exists())");
239
        appendToJava("        {");
240
        appendToJava("                System.out.println(\"FAIL:Failed to open file " + cTxtFileName + " - file not exists!\");");
241
        appendToJava("                return false;");
242
        appendToJava("        }");
243
        appendToJava("        if ( cFile.length()!=javaFile.length() )");
244
        appendToJava("        {");
245
        appendToJava("            System.out.println(\"FAIL:File length not equal!\");");
246
        appendToJava("            return false;");
247
        appendToJava("        }");
248
        appendToJava("        long byteCount=cFile.length();");
249

250

251
        appendToJava("        try{");
252
        appendToJava("            FileInputStream fisC=new FileInputStream(cFile);");
253
        appendToJava("            FileInputStream fisJava=new FileInputStream(javaFile);");
254
        appendToJava("            byte[] cData=new byte[fisC.available()];");
255
        appendToJava("            fisC.read(cData);");
256
        appendToJava("            byte[] javaData=new byte[fisJava.available()];");
257
        appendToJava("            fisJava.read(javaData);");
258

259
        appendToJava("            for ( int cnt=0;cnt<byteCount;++cnt)");
260
        appendToJava("            {");
261
        appendToJava("                if ( cData[cnt]!=javaData[cnt] )");
262
        appendToJava("                {");
263
        appendToJava("                    System.out.println(\"FAIL:Test failed! \"+cnt+\" byte are wrong! C file - \" + cData[cnt] + \" Java file - \"+javaData[cnt] );");
264
        appendToJava("                    return false;");
265
        appendToJava("                }");
266
        appendToJava("            }");
267
        appendToJava("        }");
268
        appendToJava("        catch (FileNotFoundException ex)");
269
        appendToJava("        {");
270
        appendToJava("            System.out.println(\"FAIL:Some of files not found!\");");
271
        appendToJava("            return false;");
272
        appendToJava("        }");
273
        appendToJava("        catch (IOException ex)");
274
        appendToJava("        {");
275
        appendToJava("            System.out.println(\"FAIL:Failed to read files!\");");
276
        appendToJava("            return false;");
277
        appendToJava("        }");
278
        appendToJava("        System.out.println(\"PASS: all data passed correctly!\");");
279
        appendToJava("        return true;");
280

281

282

283
        appendToJava("    }");
284

285
        appendToJava("}");
286

287

288
    }
289

290
    private void makeOneTest(int paramCounter, ParamType paramType, TestType testType, String fncName) throws IOException {
291

292
        javaFncNames.add(fncName);
293
        SrcGenerator gen = new SrcGenerator(paramCounter, 1, paramType, testType, fncName, LINE_LENGTH);
294
        generateJava(gen);
295
        generateCpp(gen);
296

297

298
    }
299

300
    /*
301
     * Create Java file containing code to call C native method. Method
302
     * arguments list generated randomly.
303
     *
304
     */
305
    private void generateJava(SrcGenerator srcGen) throws IOException {
306

307
        //native method
308
        appendToJavaN("    native public static void " + srcGen.getFncName() + "(");
309
        //appendToJavaN(srcGen.getJParm().toString());
310
        appendToJavaN(srcGen.getJParm().toFormatString("        ", LINE_LENGTH));
311
        appendToJava("    );");
312
        //main
313
        //appendToJava(srcGen.getJExecVarCreation());
314
        appendToJava("    private static void " + srcGen.getFncName() + "_invoke(PrintStream ps)");
315
        appendToJava(srcGen.getJExec("        "));
316
    }
317

318
    private void writeToJavaFile(String className) throws IOException {
319

320
        File javaFile = new File(outputDir, className + ".java");
321
        try (FileWriter javaFileWriter = new FileWriter(javaFile)) {
322
            javaFileWriter.write(javaFileSrc.toString());
323
        }
324
    }
325

326
    private void writeToCFile(String className) throws IOException {
327

328
        File cFile = new File(outputDir, className + ".c");
329
        try (FileWriter cFileWriter = new FileWriter(cFile)) {
330
            cFileWriter.write(cFileSrc.toString());
331
        }
332
    }
333

334
    private void writeTestListFile() {
335

336
        StringBuilder cfg = new StringBuilder();
337

338
        for (String fncName : javaFncNames) {
339
            cfg.append(TEST_LIST_PREFIX).append("/").append(fncName);
340
            cfg.append(" ").append("execute_positive\n");
341
        }
342

343
        File cfgFile = new File(outputDir, TEST_LIST_NAME);
344
        try (FileWriter fw = new FileWriter(cfgFile)) {
345
            fw.write(cfg.toString());
346
        } catch (Exception e) {
347
        }
348

349
    }
350

351
    private void writeCfgFile() {
352

353
        for (String fncName : javaFncNames) {
354

355
            StringBuilder cfg = new StringBuilder();
356

357
            cfg.append("LD_LIBRARY_PATH=${COMMON_LIBS_LOCATION}/lib/${ARCH}/vm/jit/LongTransitions${PS}$LD_LIBRARY_PATH\n");
358
            cfg.append("export LD_LIBRARY_PATH\n");
359
            cfg.append("JAVA_OPTS=${JAVA_OPTS} ${JIT_OPTS}\n");
360
            cfg.append("export JAVA_OPTS\n");
361
            cfg.append("EXECUTE_CLASS=" + JAVA_PACKAGE_NAME + "." + JAVA_CLASS_NAME + "\n");
362
            cfg.append("TEST_ARGS=" + fncName);
363

364
            File tdir = new File(outputDir, fncName);
365
            tdir.mkdirs();
366
            File cfgFile = new File(tdir, fncName + ".cfg");
367
            try (FileWriter fw = new FileWriter(cfgFile)) {
368
                fw.write(cfg.toString());
369
            } catch (Exception e) {
370
            }
371
        }
372
    }
373

374
    /*
375
     * Generate C file. This file containing instructions to put passed
376
     * arguments into output file for further comparsion with java output *
377
     */
378
    private void generateCpp(SrcGenerator srcGen) throws IOException {
379

380
        appendToC("JNIEXPORT void JNICALL " + C_FNC_NAME_PREFIX + srcGen.getFncName() + "(JNIEnv *e, jclass c");
381
        appendToCN(srcGen.getCParm().toFormatString("    ", LINE_LENGTH));
382
        appendToCN(")");
383
        appendToC("\n{");
384

385
        appendToCN("    FILE *file=fopen(\"");
386
        appendToCN(cTxtFileName);
387
        appendToCN("\",\"a\");");
388

389
        appendToC(srcGen.getCExec(LINE_LENGTH,"    "));
390
        appendToC("    fclose(file);");
391
        appendToC("}");
392
    }
393

394
    private void appendToJava(String s) {
395
        javaFileSrc.append(s);
396
        javaFileSrc.append("\n");
397
        System.out.println(s);
398
    }
399

400
    private void appendToJavaN(String s) {
401
        javaFileSrc.append(s);
402
        System.out.print(s);
403
    }
404

405
    private void appendToC(String s) {
406
        cFileSrc.append(s);
407
        cFileSrc.append("\n");
408
        System.out.println(s);
409
    }
410

411
    private void appendToCN(String s) {
412
        cFileSrc.append(s);
413
        System.out.print(s);
414

415
    }
416
}
417

418
enum NumberType {
419

420
    INT("int ", "getRndInt()", "jint ", "%d", "%d"),
421
    DOUBLE("double ", "getRndDouble()", "jdouble ", "%e", "%e"),
422
    FLOAT("float ", "getRndFloat()", "jfloat ", "%e", "%e"),
423
    BYTE("byte ", "getRndByte()", "jbyte ", "%d", "%d");
424
    private String cType;
425
    private String jType;
426
    private String cConv;
427
    private String jConv;
428
    private String rndFnc;
429

430
    NumberType(String jType, String rndFnc, String cType, String jConv, String cConv) {
431
        this.cType = cType;
432
        this.jType = jType;
433
        this.cConv = cConv;
434
        this.jConv = jConv;
435
        this.rndFnc = rndFnc;
436
    }
437

438
    public String getСType() {
439
        return cType;
440
    }
441

442
    public String getJType() {
443
        return jType;
444
    }
445

446
    public String getСConv() {
447
        return cConv;
448
    }
449

450
    public String getJConv() {
451
        return jConv;
452
    }
453

454
    public String getFnc() {
455
        return rndFnc;
456
    }
457
}
458

459
//Types for testing
460
enum ParamType {
461
    //DFBI
462

463
    MIXED_DFBI1(NumberType.DOUBLE, NumberType.FLOAT, NumberType.BYTE, NumberType.INT),
464
    MIXED_DFBI2(NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.BYTE, NumberType.INT),
465
    MIXED_DFBI3(NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.BYTE, NumberType.INT),
466
    MIXED_DFBI4(NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.BYTE, NumberType.INT),
467
    MIXED_DFBI5(NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.BYTE, NumberType.INT),
468
    //DFB
469
    MIXED_DFB1(NumberType.DOUBLE, NumberType.FLOAT, NumberType.BYTE),
470
    MIXED_DFB2(NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.BYTE),
471
    MIXED_DFB3(NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.BYTE),
472
    MIXED_DFB4(NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.BYTE),
473
    MIXED_DFB5(NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.BYTE),
474
    //DFI
475
    MIXED_DFI1(NumberType.DOUBLE, NumberType.FLOAT, NumberType.INT),
476
    MIXED_DFI2(NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.INT),
477
    MIXED_DFI3(NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.INT),
478
    MIXED_DFI4(NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.INT),
479
    MIXED_DFI5(NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.DOUBLE, NumberType.FLOAT, NumberType.INT),
480
    //
481
    MIXED_DF1(NumberType.DOUBLE, NumberType.FLOAT),
482
    MIXED_DF2(NumberType.DOUBLE, NumberType.FLOAT, NumberType.FLOAT),
483
    MIXED_DF3(NumberType.DOUBLE, NumberType.FLOAT, NumberType.FLOAT, NumberType.FLOAT),
484
    MIXED_DF4(NumberType.DOUBLE, NumberType.DOUBLE, NumberType.FLOAT),
485
    MIXED_DF5(NumberType.DOUBLE, NumberType.DOUBLE, NumberType.DOUBLE, NumberType.FLOAT),
486
    //
487
    EASY_D(NumberType.DOUBLE),
488
    EASY_F(NumberType.FLOAT),
489
    //Not needed
490
    EASY_I(NumberType.INT),
491
    EASY_B(NumberType.BYTE),
492
    MIXED_IB(NumberType.INT, NumberType.BYTE),
493
    //
494
    MIXED_FBI1(NumberType.FLOAT, NumberType.BYTE, NumberType.INT),
495
    MIXED_FBI2(NumberType.FLOAT, NumberType.FLOAT, NumberType.BYTE, NumberType.INT),
496
    MIXED_FBI3(NumberType.FLOAT, NumberType.FLOAT, NumberType.FLOAT, NumberType.BYTE, NumberType.INT),
497
    MIXED_FBI4(NumberType.FLOAT, NumberType.FLOAT, NumberType.FLOAT, NumberType.FLOAT, NumberType.BYTE, NumberType.INT),
498
    MIXED_FBI5(NumberType.FLOAT, NumberType.FLOAT, NumberType.FLOAT, NumberType.FLOAT, NumberType.FLOAT, NumberType.BYTE, NumberType.INT),
499
    //
500
    MIXED_FB1(NumberType.FLOAT, NumberType.BYTE),
501
    MIXED_FB2(NumberType.FLOAT, NumberType.FLOAT, NumberType.BYTE),
502
    MIXED_FB3(NumberType.FLOAT, NumberType.FLOAT, NumberType.FLOAT, NumberType.BYTE),
503
    MIXED_FB4(NumberType.FLOAT, NumberType.FLOAT, NumberType.FLOAT, NumberType.FLOAT, NumberType.BYTE),
504
    MIXED_FB5(NumberType.FLOAT, NumberType.FLOAT, NumberType.FLOAT, NumberType.FLOAT, NumberType.FLOAT, NumberType.BYTE),
505
    //
506
    MIXED_DBI1(NumberType.DOUBLE, NumberType.BYTE, NumberType.INT),
507
    MIXED_DBI2(NumberType.DOUBLE, NumberType.DOUBLE, NumberType.BYTE, NumberType.INT),
508
    MIXED_DBI3(NumberType.DOUBLE, NumberType.DOUBLE, NumberType.DOUBLE, NumberType.BYTE, NumberType.INT),
509
    MIXED_DBI4(NumberType.DOUBLE, NumberType.DOUBLE, NumberType.DOUBLE, NumberType.DOUBLE, NumberType.BYTE, NumberType.INT),
510
    MIXED_DBI5(NumberType.DOUBLE, NumberType.DOUBLE, NumberType.DOUBLE, NumberType.DOUBLE, NumberType.DOUBLE, NumberType.BYTE, NumberType.INT),
511
    //
512
    MIXED_DB1(NumberType.DOUBLE, NumberType.BYTE),
513
    MIXED_DB2(NumberType.DOUBLE, NumberType.DOUBLE, NumberType.BYTE),
514
    MIXED_DB3(NumberType.DOUBLE, NumberType.DOUBLE, NumberType.DOUBLE, NumberType.BYTE),
515
    MIXED_DB4(NumberType.DOUBLE, NumberType.DOUBLE, NumberType.DOUBLE, NumberType.DOUBLE, NumberType.BYTE),
516
    MIXED_DB5(NumberType.DOUBLE, NumberType.DOUBLE, NumberType.DOUBLE, NumberType.DOUBLE, NumberType.DOUBLE, NumberType.BYTE),
517
    //
518
    MIXED_FI1(NumberType.FLOAT, NumberType.INT),
519
    MIXED_FI2(NumberType.FLOAT, NumberType.FLOAT, NumberType.INT),
520
    MIXED_FI3(NumberType.FLOAT, NumberType.FLOAT, NumberType.FLOAT, NumberType.INT),
521
    MIXED_FI4(NumberType.FLOAT, NumberType.FLOAT, NumberType.FLOAT, NumberType.FLOAT, NumberType.INT),
522
    MIXED_FI5(NumberType.FLOAT, NumberType.FLOAT, NumberType.FLOAT, NumberType.FLOAT, NumberType.FLOAT, NumberType.INT),
523
    //
524
    MIXED_DI1(NumberType.DOUBLE, NumberType.INT),
525
    MIXED_DI2(NumberType.DOUBLE, NumberType.DOUBLE, NumberType.INT),
526
    MIXED_DI3(NumberType.DOUBLE, NumberType.DOUBLE, NumberType.DOUBLE, NumberType.INT),
527
    MIXED_DI4(NumberType.DOUBLE, NumberType.DOUBLE, NumberType.DOUBLE, NumberType.DOUBLE, NumberType.INT),
528
    MIXED_DI5(NumberType.DOUBLE, NumberType.DOUBLE, NumberType.DOUBLE, NumberType.DOUBLE, NumberType.DOUBLE, NumberType.INT);
529
    ArrayList<NumberType> value = new ArrayList();
530

531
    ParamType(NumberType... type) {
532
        value.addAll(Arrays.asList(type));
533
    }
534

535
    public ArrayList<NumberType> getValue() {
536
        return value;
537
    }
538
}
539

540
class GeneratorLogic {
541

542
    public String generateJava(String fncName, ParameterList parmOut, ParameterList parmType, int maxLength, String prefix) {
543
        StringBuilder sb = new StringBuilder();
544

545
        sb.append("    {\n").append(prefix);
546
        int lineLength = 0;
547
        for (ParameterItem p : parmType.getList()) {
548
            sb.append(p.value1);
549
            sb.append(" ");
550
            sb.append(p.value2);
551
            sb.append("=");
552
            sb.append(p.value3);
553
            sb.append(";");
554
            if (sb.length() - lineLength > maxLength) {
555
                sb.append("\n").append(prefix);
556
                lineLength = sb.length();
557
            }
558
        }
559

560
        sb.append("\n");
561
        sb.append(prefix);
562
        for (ParameterItem p : parmOut.getList()) {
563
            sb.append("ps.format(\"");
564
            sb.append(p.value2);
565
            sb.append("=");
566
            sb.append(p.value1);
567
            sb.append("\\n\",");
568

569

570
            sb.append(p.value2);
571
            sb.append(");");
572
            if (sb.length() - lineLength > maxLength) {
573
                sb.append("\n").append(prefix);
574
                lineLength = sb.length();
575
            }
576

577
        }
578

579
        sb.append("\n").append(prefix);
580

581
        sb.append(fncName);
582
        sb.append("(");
583
        for (ParameterItem p : parmOut.getList()) {
584
            sb.append(p.getDelim());
585
            sb.append(p.value2);
586
            if (sb.length() - lineLength > maxLength) {
587
                sb.append("\n").append(prefix);
588
                lineLength = sb.length();
589
            }
590
        }
591
        sb.append(");\n}\n");
592

593
        return sb.toString();
594
    }
595
}
596

597
//Test types
598
enum TestType {
599

600
    RANDOM(new GeneratorLogic());
601
    private GeneratorLogic genLogic;
602

603
    TestType(GeneratorLogic genLogic) {
604
        this.genLogic = genLogic;
605
    }
606

607
    public GeneratorLogic getLogic() {
608
        return genLogic;
609
    }
610
}
611

612
//One item for ParameterList (delimiter and value to build strings)
613
class ParameterItem {
614

615
    private String delimiter;
616
    String value1;
617
    String value2;
618
    String value3;
619
    //private String endVal="";
620

621
    public ParameterItem(String delimiter, String value) {
622
        this.delimiter = delimiter;
623
        this.value1 = value;
624
        value2 = "";
625
        value3 = "";
626
    }
627

628
    public ParameterItem(String delimiter, String value1, String value2) {
629
        this.delimiter = delimiter;
630
        this.value1 = value1;
631
        this.value2 = value2;
632
        value3 = "";
633
    }
634

635
    public ParameterItem(String delimiter, String value1, String value2, String value3) {
636
        this.delimiter = delimiter;
637
        this.value1 = value1;
638
        this.value2 = value2;
639
        this.value3 = value3;
640
    }
641

642
    public String toString() {
643
        return delimiter + value1 + value2 + value3;
644
    }
645

646
    public String getDelim() {
647
        return delimiter;
648
    }
649
}
650
//Delimiters and values to generate calls, etc.
651
class ParameterList {
652

653
    ArrayList<ParameterItem> list = new ArrayList();
654
    private String initDelim;
655
    private String delim;
656
    boolean lineBreak;
657

658
    public ParameterList(String initialDelimiter, String delimiter, boolean lineBreak) {
659
        initDelim = initialDelimiter;
660
        delim = delimiter;
661
        this.lineBreak = lineBreak;
662
    }
663

664
    public ArrayList<ParameterItem> getList() {
665
        return list;
666
    }
667

668
    public void add(String value) {
669
        list.add(new ParameterItem(initDelim, value));
670
        initDelim = delim;
671
    }
672

673
    public void add(String value1, String value2) {
674
        list.add(new ParameterItem(initDelim, value1, value2));
675
        initDelim = delim;
676
    }
677

678
    public void add(String value1, String value2, String value3) {
679
        list.add(new ParameterItem(initDelim, value1, value2, value3));
680
        initDelim = delim;
681
    }
682

683
    public ParameterItem get(int id) {
684
        return list.get(id);
685
    }
686

687
    public String toString() {
688
        StringBuilder sb = new StringBuilder();
689
        for (ParameterItem p : list) {
690
            sb.append(p.toString());
691
            if (lineBreak) {
692
                sb.append("\n");
693
            }
694

695
        }
696
        return sb.toString();
697
    }
698

699
    public String toFormatString(String prefix, int maxLength) {
700
        StringBuilder sb = new StringBuilder();
701
        int charCount = 0;
702
        for (ParameterItem p : list) {
703
            sb.append(p.toString());
704
            if (sb.length() - charCount > maxLength) {
705
                sb.append("\n").append(prefix);
706
                charCount = sb.length();
707
            }
708
        }
709
        return sb.toString();
710
    }
711

712
    public int size() {
713
        return list.size();
714
    }
715

716
    public String getAllItemExclude(int excludeId) {
717
        StringBuilder sb = new StringBuilder();
718
        int cnt = list.size();
719

720
        for (int id = 0; id < cnt; ++id) {
721
            ParameterItem p = list.get(id);
722
            if (id == excludeId) {
723
                sb.append(p.getDelim());
724
                sb.append("0");
725
            } else {
726
                sb.append(p.toString());
727

728
            }
729
        }
730

731
        return sb.toString();
732

733
    }
734

735
    public String getAllItemExcludeNot(int excludeId) {
736
        StringBuilder sb = new StringBuilder();
737
        int cnt = list.size();
738

739
        for (int id = 0; id < cnt; ++id) {
740
            ParameterItem p = list.get(id);
741
            if (id != excludeId) {
742
                sb.append(p.getDelim());
743
                sb.append("0");
744
//                sb.append(p.getEnd());
745
            } else {
746
                sb.append(p.toString());
747

748
            }
749
        }
750

751
        return sb.toString();
752
    }
753
}
754

755
class ParameterListGenerator {
756

757
    private ArrayList<NumberType> list = new ArrayList();
758
    private Random random;
759
    private int typeCnt;
760
    ParameterList cParms = new ParameterList(",", ",", true);
761
    ParameterList rParms = new ParameterList("", ",", true);
762
    ParameterList jParms = new ParameterList("", ",", true);
763
    ParameterList cExec = new ParameterList("", "", true);
764
    ParameterList jExecParm = new ParameterList("", ",", true);
765
    ParameterList jExecOut = new ParameterList("", ",", true);
766

767
    public ParameterListGenerator(int length, ParamType paramType) {
768
        generateRndTest(paramType, length);
769
    }
770

771
    private void add(ParameterList list, String s1) {
772
        list.add(s1);
773
    }
774

775
    private void add(ParameterList list, String s1, String s2) {
776
        list.add(s1, s2);
777
    }
778

779
    private void add(ParameterList list, String s1, String s2, String s3) {
780
        list.add(s1, s2, s3);
781
    }
782

783
    private void generateRndTest(ParamType paramType, int length) {
784
        generateTypeList(paramType);
785

786
        typeCnt = list.size();
787
        random = new Random();
788
        random.setSeed(System.currentTimeMillis());
789

790
        for (int cnt = 0; cnt < length; ++cnt) {
791
            int type = random.nextInt(typeCnt);
792

793
            String randomVal = list.get(type).getFnc();
794

795
            String ctype = list.get(type).getСType();
796
            String jtype = list.get(type).getJType();
797
            String cconv = list.get(type).getСConv();
798
            String jconv = list.get(type).getJConv();
799

800
            String varName = "p" + cnt;
801
            add(jParms, jtype, varName);
802
            //jParmGen.add(jtype + varName);
803

804
            //cParms.add(ctype + varName);
805
            add(cParms, ctype, varName);
806

807

808
            //rParms.add(varName);
809
            add(rParms, varName);
810

811
            add(cExec, varName, cconv);
812

813
            add(jExecParm, jtype, varName, randomVal);
814
            //jExecOut.add(new PairString(jconv,varName,jtype));
815
            add(jExecOut, jconv, varName, jtype);
816
        }
817

818
    }
819

820
    public ParameterList getCExec() {
821
        return cExec;
822
    }
823

824
    public ParameterList getCParm() {
825
        return cParms;
826
    }
827

828
    //Return generated java text
829
    public ParameterList getJExecParameters() {
830
        return jExecParm;
831
    }
832

833
    public ParameterList getJExecOut() {
834
        return jExecOut;
835
    }
836

837
    /*
838
     * Return string containing parameters for Java
839
     */
840
    public ParameterList getJParm() {
841
        return jParms;
842
    }
843

844
    public ParameterList getRParm() {
845
        return rParms;
846
    }
847

848
    private void generateTypeList(ParamType paramType) {
849
        list.addAll(paramType.getValue());
850
    }
851
}
852

853
class SrcGenerator {
854

855
    ParameterListGenerator parmListGen;
856
    GeneratorLogic genLogic;
857
    int iterationCounter;
858
    int parametersCounter;
859
    ParamType paramType;
860
    TestType testType;
861
    String fncName;
862
    //SrcGenerator g1=new SrcGenerator(3,1,ParamType.MIXED_DFIB,TestType.RANDOM,"callRandom");
863
    int maxLength;
864

865
    public SrcGenerator(int parmCounter, int iterCounter, ParamType parType, TestType testType, String fncName, int maxLength) {
866
        this.maxLength = maxLength;
867
        parametersCounter = parmCounter;
868
        iterationCounter = iterCounter;
869
        paramType = parType;
870
        this.testType = testType;
871
        this.fncName = fncName;
872
        parmListGen = new ParameterListGenerator(parametersCounter, paramType);
873
        genLogic = testType.getLogic();
874

875
    }
876

877
    public String getFncName() {
878
        return fncName;
879
    }
880

881
    public ParameterList getJParm() {
882
        return parmListGen.getJParm();
883
    }
884

885
    public ParameterList getCParm() {
886
        return parmListGen.getCParm();
887
    }
888

889
    public String getCExec() {
890

891
        StringBuilder sb = new StringBuilder();
892
        for (ParameterItem p : parmListGen.getCExec().getList()) {
893
            sb.append("fprintf(file,\"");
894
            sb.append(p.value1);
895
            sb.append("=");
896
            sb.append(p.value2);
897
            sb.append("\\n\",");
898
            sb.append(p.value1);
899
            sb.append(");\n");
900
        }
901
        return sb.toString();
902
    }
903

904
    public String getCExec(int maxLength,String prefix) {
905

906
        int lineLength = 0;
907
        StringBuilder sb = new StringBuilder();
908
        for (ParameterItem p : parmListGen.getCExec().getList()) {
909
            sb.append("fprintf(file,\"");
910
            sb.append(p.value1);
911
            sb.append("=");
912
            sb.append(p.value2);
913
            sb.append("\\n\",");
914
            sb.append(p.value1);
915
            sb.append(");");
916
            if (sb.length() - lineLength > maxLength) {
917
                lineLength = sb.length();
918
                sb.append("\n").append(prefix);
919
            }
920
        }
921
        return sb.toString();
922
    }
923

924
    public String getJExec(String prefix) {
925
        return genLogic.generateJava(fncName, parmListGen.getJExecOut(), parmListGen.getJExecParameters(), maxLength, prefix);
926

927
    }
928
}
929

930
Product

Resources

Company
