1 /* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 // Don't edit this file! It is auto-generated by frameworks/rs/api/generate.sh. 18 19 package android.renderscript.cts; 20 21 import android.renderscript.Allocation; 22 import android.renderscript.RSRuntimeException; 23 import android.renderscript.Element; 24 import android.renderscript.cts.Target; 25 26 import java.util.Arrays; 27 28 public class TestNativeLength extends RSBaseCompute { 29 30 private ScriptC_TestNativeLength script; 31 private ScriptC_TestNativeLengthRelaxed scriptRelaxed; 32 33 @Override 34 protected void setUp() throws Exception { 35 super.setUp(); 36 script = new ScriptC_TestNativeLength(mRS); 37 scriptRelaxed = new ScriptC_TestNativeLengthRelaxed(mRS); 38 } 39 40 @Override 41 protected void tearDown() throws Exception { 42 script.destroy(); 43 scriptRelaxed.destroy(); 44 super.tearDown(); 45 } 46 47 public class ArgumentsFloatFloat { 48 public float inV; 49 public Target.Floaty out; 50 } 51 52 private void checkNativeLengthFloatFloat() { 53 Allocation inV = createRandomAllocation(mRS, Element.DataType.FLOAT_32, 1, 0xbe51f0c4d1df20ecl, false); 54 try { 55 Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_32, 1), INPUTSIZE); 56 script.forEach_testNativeLengthFloatFloat(inV, out); 57 verifyResultsNativeLengthFloatFloat(inV, out, false); 58 out.destroy(); 59 } catch (Exception e) { 60 throw new RSRuntimeException("RenderScript. Can't invoke forEach_testNativeLengthFloatFloat: " + e.toString()); 61 } 62 try { 63 Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_32, 1), INPUTSIZE); 64 scriptRelaxed.forEach_testNativeLengthFloatFloat(inV, out); 65 verifyResultsNativeLengthFloatFloat(inV, out, true); 66 out.destroy(); 67 } catch (Exception e) { 68 throw new RSRuntimeException("RenderScript. Can't invoke forEach_testNativeLengthFloatFloat: " + e.toString()); 69 } 70 inV.destroy(); 71 } 72 73 private void verifyResultsNativeLengthFloatFloat(Allocation inV, Allocation out, boolean relaxed) { 74 float[] arrayInV = new float[INPUTSIZE * 1]; 75 Arrays.fill(arrayInV, (float) 42); 76 inV.copyTo(arrayInV); 77 float[] arrayOut = new float[INPUTSIZE * 1]; 78 Arrays.fill(arrayOut, (float) 42); 79 out.copyTo(arrayOut); 80 StringBuilder message = new StringBuilder(); 81 boolean errorFound = false; 82 for (int i = 0; i < INPUTSIZE; i++) { 83 ArgumentsFloatFloat args = new ArgumentsFloatFloat(); 84 // Create the appropriate sized arrays in args 85 // Fill args with the input values 86 args.inV = arrayInV[i]; 87 Target target = new Target(Target.FunctionType.NATIVE, Target.ReturnType.FLOAT, relaxed); 88 CoreMathVerifier.computeNativeLength(args, target); 89 90 // Compare the expected outputs to the actual values returned by RS. 91 boolean valid = true; 92 if (!args.out.couldBe(arrayOut[i])) { 93 valid = false; 94 } 95 if (!valid) { 96 if (!errorFound) { 97 errorFound = true; 98 message.append("Input inV: "); 99 appendVariableToMessage(message, arrayInV[i]); 100 message.append("\n"); 101 message.append("Expected output out: "); 102 appendVariableToMessage(message, args.out); 103 message.append("\n"); 104 message.append("Actual output out: "); 105 appendVariableToMessage(message, arrayOut[i]); 106 if (!args.out.couldBe(arrayOut[i])) { 107 message.append(" FAIL"); 108 } 109 message.append("\n"); 110 message.append("Errors at"); 111 } 112 message.append(" ["); 113 message.append(Integer.toString(i)); 114 message.append("]"); 115 } 116 } 117 assertFalse("Incorrect output for checkNativeLengthFloatFloat" + 118 (relaxed ? "_relaxed" : "") + ":\n" + message.toString(), errorFound); 119 } 120 121 public class ArgumentsFloatNFloat { 122 public float[] inV; 123 public Target.Floaty out; 124 } 125 126 private void checkNativeLengthFloat2Float() { 127 Allocation inV = createRandomAllocation(mRS, Element.DataType.FLOAT_32, 2, 0xf7c2930af1b4824cl, false); 128 try { 129 Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_32, 1), INPUTSIZE); 130 script.forEach_testNativeLengthFloat2Float(inV, out); 131 verifyResultsNativeLengthFloat2Float(inV, out, false); 132 out.destroy(); 133 } catch (Exception e) { 134 throw new RSRuntimeException("RenderScript. Can't invoke forEach_testNativeLengthFloat2Float: " + e.toString()); 135 } 136 try { 137 Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_32, 1), INPUTSIZE); 138 scriptRelaxed.forEach_testNativeLengthFloat2Float(inV, out); 139 verifyResultsNativeLengthFloat2Float(inV, out, true); 140 out.destroy(); 141 } catch (Exception e) { 142 throw new RSRuntimeException("RenderScript. Can't invoke forEach_testNativeLengthFloat2Float: " + e.toString()); 143 } 144 inV.destroy(); 145 } 146 147 private void verifyResultsNativeLengthFloat2Float(Allocation inV, Allocation out, boolean relaxed) { 148 float[] arrayInV = new float[INPUTSIZE * 2]; 149 Arrays.fill(arrayInV, (float) 42); 150 inV.copyTo(arrayInV); 151 float[] arrayOut = new float[INPUTSIZE * 1]; 152 Arrays.fill(arrayOut, (float) 42); 153 out.copyTo(arrayOut); 154 StringBuilder message = new StringBuilder(); 155 boolean errorFound = false; 156 for (int i = 0; i < INPUTSIZE; i++) { 157 ArgumentsFloatNFloat args = new ArgumentsFloatNFloat(); 158 // Create the appropriate sized arrays in args 159 args.inV = new float[2]; 160 // Fill args with the input values 161 for (int j = 0; j < 2 ; j++) { 162 args.inV[j] = arrayInV[i * 2 + j]; 163 } 164 Target target = new Target(Target.FunctionType.NATIVE, Target.ReturnType.FLOAT, relaxed); 165 CoreMathVerifier.computeNativeLength(args, target); 166 167 // Compare the expected outputs to the actual values returned by RS. 168 boolean valid = true; 169 if (!args.out.couldBe(arrayOut[i])) { 170 valid = false; 171 } 172 if (!valid) { 173 if (!errorFound) { 174 errorFound = true; 175 for (int j = 0; j < 2 ; j++) { 176 message.append("Input inV: "); 177 appendVariableToMessage(message, arrayInV[i * 2 + j]); 178 message.append("\n"); 179 } 180 message.append("Expected output out: "); 181 appendVariableToMessage(message, args.out); 182 message.append("\n"); 183 message.append("Actual output out: "); 184 appendVariableToMessage(message, arrayOut[i]); 185 if (!args.out.couldBe(arrayOut[i])) { 186 message.append(" FAIL"); 187 } 188 message.append("\n"); 189 message.append("Errors at"); 190 } 191 message.append(" ["); 192 message.append(Integer.toString(i)); 193 message.append("]"); 194 } 195 } 196 assertFalse("Incorrect output for checkNativeLengthFloat2Float" + 197 (relaxed ? "_relaxed" : "") + ":\n" + message.toString(), errorFound); 198 } 199 200 private void checkNativeLengthFloat3Float() { 201 Allocation inV = createRandomAllocation(mRS, Element.DataType.FLOAT_32, 3, 0xf7c29dac50bb10adl, false); 202 try { 203 Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_32, 1), INPUTSIZE); 204 script.forEach_testNativeLengthFloat3Float(inV, out); 205 verifyResultsNativeLengthFloat3Float(inV, out, false); 206 out.destroy(); 207 } catch (Exception e) { 208 throw new RSRuntimeException("RenderScript. Can't invoke forEach_testNativeLengthFloat3Float: " + e.toString()); 209 } 210 try { 211 Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_32, 1), INPUTSIZE); 212 scriptRelaxed.forEach_testNativeLengthFloat3Float(inV, out); 213 verifyResultsNativeLengthFloat3Float(inV, out, true); 214 out.destroy(); 215 } catch (Exception e) { 216 throw new RSRuntimeException("RenderScript. Can't invoke forEach_testNativeLengthFloat3Float: " + e.toString()); 217 } 218 inV.destroy(); 219 } 220 221 private void verifyResultsNativeLengthFloat3Float(Allocation inV, Allocation out, boolean relaxed) { 222 float[] arrayInV = new float[INPUTSIZE * 4]; 223 Arrays.fill(arrayInV, (float) 42); 224 inV.copyTo(arrayInV); 225 float[] arrayOut = new float[INPUTSIZE * 1]; 226 Arrays.fill(arrayOut, (float) 42); 227 out.copyTo(arrayOut); 228 StringBuilder message = new StringBuilder(); 229 boolean errorFound = false; 230 for (int i = 0; i < INPUTSIZE; i++) { 231 ArgumentsFloatNFloat args = new ArgumentsFloatNFloat(); 232 // Create the appropriate sized arrays in args 233 args.inV = new float[3]; 234 // Fill args with the input values 235 for (int j = 0; j < 3 ; j++) { 236 args.inV[j] = arrayInV[i * 4 + j]; 237 } 238 Target target = new Target(Target.FunctionType.NATIVE, Target.ReturnType.FLOAT, relaxed); 239 CoreMathVerifier.computeNativeLength(args, target); 240 241 // Compare the expected outputs to the actual values returned by RS. 242 boolean valid = true; 243 if (!args.out.couldBe(arrayOut[i])) { 244 valid = false; 245 } 246 if (!valid) { 247 if (!errorFound) { 248 errorFound = true; 249 for (int j = 0; j < 3 ; j++) { 250 message.append("Input inV: "); 251 appendVariableToMessage(message, arrayInV[i * 4 + j]); 252 message.append("\n"); 253 } 254 message.append("Expected output out: "); 255 appendVariableToMessage(message, args.out); 256 message.append("\n"); 257 message.append("Actual output out: "); 258 appendVariableToMessage(message, arrayOut[i]); 259 if (!args.out.couldBe(arrayOut[i])) { 260 message.append(" FAIL"); 261 } 262 message.append("\n"); 263 message.append("Errors at"); 264 } 265 message.append(" ["); 266 message.append(Integer.toString(i)); 267 message.append("]"); 268 } 269 } 270 assertFalse("Incorrect output for checkNativeLengthFloat3Float" + 271 (relaxed ? "_relaxed" : "") + ":\n" + message.toString(), errorFound); 272 } 273 274 private void checkNativeLengthFloat4Float() { 275 Allocation inV = createRandomAllocation(mRS, Element.DataType.FLOAT_32, 4, 0xf7c2a84dafc19f0el, false); 276 try { 277 Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_32, 1), INPUTSIZE); 278 script.forEach_testNativeLengthFloat4Float(inV, out); 279 verifyResultsNativeLengthFloat4Float(inV, out, false); 280 out.destroy(); 281 } catch (Exception e) { 282 throw new RSRuntimeException("RenderScript. Can't invoke forEach_testNativeLengthFloat4Float: " + e.toString()); 283 } 284 try { 285 Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_32, 1), INPUTSIZE); 286 scriptRelaxed.forEach_testNativeLengthFloat4Float(inV, out); 287 verifyResultsNativeLengthFloat4Float(inV, out, true); 288 out.destroy(); 289 } catch (Exception e) { 290 throw new RSRuntimeException("RenderScript. Can't invoke forEach_testNativeLengthFloat4Float: " + e.toString()); 291 } 292 inV.destroy(); 293 } 294 295 private void verifyResultsNativeLengthFloat4Float(Allocation inV, Allocation out, boolean relaxed) { 296 float[] arrayInV = new float[INPUTSIZE * 4]; 297 Arrays.fill(arrayInV, (float) 42); 298 inV.copyTo(arrayInV); 299 float[] arrayOut = new float[INPUTSIZE * 1]; 300 Arrays.fill(arrayOut, (float) 42); 301 out.copyTo(arrayOut); 302 StringBuilder message = new StringBuilder(); 303 boolean errorFound = false; 304 for (int i = 0; i < INPUTSIZE; i++) { 305 ArgumentsFloatNFloat args = new ArgumentsFloatNFloat(); 306 // Create the appropriate sized arrays in args 307 args.inV = new float[4]; 308 // Fill args with the input values 309 for (int j = 0; j < 4 ; j++) { 310 args.inV[j] = arrayInV[i * 4 + j]; 311 } 312 Target target = new Target(Target.FunctionType.NATIVE, Target.ReturnType.FLOAT, relaxed); 313 CoreMathVerifier.computeNativeLength(args, target); 314 315 // Compare the expected outputs to the actual values returned by RS. 316 boolean valid = true; 317 if (!args.out.couldBe(arrayOut[i])) { 318 valid = false; 319 } 320 if (!valid) { 321 if (!errorFound) { 322 errorFound = true; 323 for (int j = 0; j < 4 ; j++) { 324 message.append("Input inV: "); 325 appendVariableToMessage(message, arrayInV[i * 4 + j]); 326 message.append("\n"); 327 } 328 message.append("Expected output out: "); 329 appendVariableToMessage(message, args.out); 330 message.append("\n"); 331 message.append("Actual output out: "); 332 appendVariableToMessage(message, arrayOut[i]); 333 if (!args.out.couldBe(arrayOut[i])) { 334 message.append(" FAIL"); 335 } 336 message.append("\n"); 337 message.append("Errors at"); 338 } 339 message.append(" ["); 340 message.append(Integer.toString(i)); 341 message.append("]"); 342 } 343 } 344 assertFalse("Incorrect output for checkNativeLengthFloat4Float" + 345 (relaxed ? "_relaxed" : "") + ":\n" + message.toString(), errorFound); 346 } 347 348 public class ArgumentsHalfHalf { 349 public short inV; 350 public double inVDouble; 351 public Target.Floaty out; 352 } 353 354 private void checkNativeLengthHalfHalf() { 355 Allocation inV = createRandomAllocation(mRS, Element.DataType.FLOAT_16, 1, 0x576f8cda01777436l, false); 356 try { 357 Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_16, 1), INPUTSIZE); 358 script.forEach_testNativeLengthHalfHalf(inV, out); 359 verifyResultsNativeLengthHalfHalf(inV, out, false); 360 out.destroy(); 361 } catch (Exception e) { 362 throw new RSRuntimeException("RenderScript. Can't invoke forEach_testNativeLengthHalfHalf: " + e.toString()); 363 } 364 try { 365 Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_16, 1), INPUTSIZE); 366 scriptRelaxed.forEach_testNativeLengthHalfHalf(inV, out); 367 verifyResultsNativeLengthHalfHalf(inV, out, true); 368 out.destroy(); 369 } catch (Exception e) { 370 throw new RSRuntimeException("RenderScript. Can't invoke forEach_testNativeLengthHalfHalf: " + e.toString()); 371 } 372 inV.destroy(); 373 } 374 375 private void verifyResultsNativeLengthHalfHalf(Allocation inV, Allocation out, boolean relaxed) { 376 short[] arrayInV = new short[INPUTSIZE * 1]; 377 Arrays.fill(arrayInV, (short) 42); 378 inV.copyTo(arrayInV); 379 short[] arrayOut = new short[INPUTSIZE * 1]; 380 Arrays.fill(arrayOut, (short) 42); 381 out.copyTo(arrayOut); 382 StringBuilder message = new StringBuilder(); 383 boolean errorFound = false; 384 for (int i = 0; i < INPUTSIZE; i++) { 385 ArgumentsHalfHalf args = new ArgumentsHalfHalf(); 386 // Create the appropriate sized arrays in args 387 // Fill args with the input values 388 args.inV = arrayInV[i]; 389 args.inVDouble = Float16Utils.convertFloat16ToDouble(args.inV); 390 Target target = new Target(Target.FunctionType.NATIVE, Target.ReturnType.HALF, relaxed); 391 CoreMathVerifier.computeNativeLength(args, target); 392 393 // Compare the expected outputs to the actual values returned by RS. 394 boolean valid = true; 395 if (!args.out.couldBe(Float16Utils.convertFloat16ToDouble(arrayOut[i]))) { 396 valid = false; 397 } 398 if (!valid) { 399 if (!errorFound) { 400 errorFound = true; 401 message.append("Input inV: "); 402 appendVariableToMessage(message, arrayInV[i]); 403 message.append("\n"); 404 message.append("Expected output out: "); 405 appendVariableToMessage(message, args.out); 406 message.append("\n"); 407 message.append("Actual output out: "); 408 appendVariableToMessage(message, arrayOut[i]); 409 message.append("\n"); 410 message.append("Actual output out (in double): "); 411 appendVariableToMessage(message, Float16Utils.convertFloat16ToDouble(arrayOut[i])); 412 if (!args.out.couldBe(Float16Utils.convertFloat16ToDouble(arrayOut[i]))) { 413 message.append(" FAIL"); 414 } 415 message.append("\n"); 416 message.append("Errors at"); 417 } 418 message.append(" ["); 419 message.append(Integer.toString(i)); 420 message.append("]"); 421 } 422 } 423 assertFalse("Incorrect output for checkNativeLengthHalfHalf" + 424 (relaxed ? "_relaxed" : "") + ":\n" + message.toString(), errorFound); 425 } 426 427 public class ArgumentsHalfNHalf { 428 public short[] inV; 429 public double[] inVDouble; 430 public Target.Floaty out; 431 } 432 433 private void checkNativeLengthHalf2Half() { 434 Allocation inV = createRandomAllocation(mRS, Element.DataType.FLOAT_16, 2, 0xafbca308bffb8a74l, false); 435 try { 436 Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_16, 1), INPUTSIZE); 437 script.forEach_testNativeLengthHalf2Half(inV, out); 438 verifyResultsNativeLengthHalf2Half(inV, out, false); 439 out.destroy(); 440 } catch (Exception e) { 441 throw new RSRuntimeException("RenderScript. Can't invoke forEach_testNativeLengthHalf2Half: " + e.toString()); 442 } 443 try { 444 Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_16, 1), INPUTSIZE); 445 scriptRelaxed.forEach_testNativeLengthHalf2Half(inV, out); 446 verifyResultsNativeLengthHalf2Half(inV, out, true); 447 out.destroy(); 448 } catch (Exception e) { 449 throw new RSRuntimeException("RenderScript. Can't invoke forEach_testNativeLengthHalf2Half: " + e.toString()); 450 } 451 inV.destroy(); 452 } 453 454 private void verifyResultsNativeLengthHalf2Half(Allocation inV, Allocation out, boolean relaxed) { 455 short[] arrayInV = new short[INPUTSIZE * 2]; 456 Arrays.fill(arrayInV, (short) 42); 457 inV.copyTo(arrayInV); 458 short[] arrayOut = new short[INPUTSIZE * 1]; 459 Arrays.fill(arrayOut, (short) 42); 460 out.copyTo(arrayOut); 461 StringBuilder message = new StringBuilder(); 462 boolean errorFound = false; 463 for (int i = 0; i < INPUTSIZE; i++) { 464 ArgumentsHalfNHalf args = new ArgumentsHalfNHalf(); 465 // Create the appropriate sized arrays in args 466 args.inV = new short[2]; 467 args.inVDouble = new double[2]; 468 // Fill args with the input values 469 for (int j = 0; j < 2 ; j++) { 470 args.inV[j] = arrayInV[i * 2 + j]; 471 args.inVDouble[j] = Float16Utils.convertFloat16ToDouble(args.inV[j]); 472 } 473 Target target = new Target(Target.FunctionType.NATIVE, Target.ReturnType.HALF, relaxed); 474 CoreMathVerifier.computeNativeLength(args, target); 475 476 // Compare the expected outputs to the actual values returned by RS. 477 boolean valid = true; 478 if (!args.out.couldBe(Float16Utils.convertFloat16ToDouble(arrayOut[i]))) { 479 valid = false; 480 } 481 if (!valid) { 482 if (!errorFound) { 483 errorFound = true; 484 for (int j = 0; j < 2 ; j++) { 485 message.append("Input inV: "); 486 appendVariableToMessage(message, arrayInV[i * 2 + j]); 487 message.append("\n"); 488 } 489 message.append("Expected output out: "); 490 appendVariableToMessage(message, args.out); 491 message.append("\n"); 492 message.append("Actual output out: "); 493 appendVariableToMessage(message, arrayOut[i]); 494 message.append("\n"); 495 message.append("Actual output out (in double): "); 496 appendVariableToMessage(message, Float16Utils.convertFloat16ToDouble(arrayOut[i])); 497 if (!args.out.couldBe(Float16Utils.convertFloat16ToDouble(arrayOut[i]))) { 498 message.append(" FAIL"); 499 } 500 message.append("\n"); 501 message.append("Errors at"); 502 } 503 message.append(" ["); 504 message.append(Integer.toString(i)); 505 message.append("]"); 506 } 507 } 508 assertFalse("Incorrect output for checkNativeLengthHalf2Half" + 509 (relaxed ? "_relaxed" : "") + ":\n" + message.toString(), errorFound); 510 } 511 512 private void checkNativeLengthHalf3Half() { 513 Allocation inV = createRandomAllocation(mRS, Element.DataType.FLOAT_16, 3, 0xafbca34809a26417l, false); 514 try { 515 Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_16, 1), INPUTSIZE); 516 script.forEach_testNativeLengthHalf3Half(inV, out); 517 verifyResultsNativeLengthHalf3Half(inV, out, false); 518 out.destroy(); 519 } catch (Exception e) { 520 throw new RSRuntimeException("RenderScript. Can't invoke forEach_testNativeLengthHalf3Half: " + e.toString()); 521 } 522 try { 523 Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_16, 1), INPUTSIZE); 524 scriptRelaxed.forEach_testNativeLengthHalf3Half(inV, out); 525 verifyResultsNativeLengthHalf3Half(inV, out, true); 526 out.destroy(); 527 } catch (Exception e) { 528 throw new RSRuntimeException("RenderScript. Can't invoke forEach_testNativeLengthHalf3Half: " + e.toString()); 529 } 530 inV.destroy(); 531 } 532 533 private void verifyResultsNativeLengthHalf3Half(Allocation inV, Allocation out, boolean relaxed) { 534 short[] arrayInV = new short[INPUTSIZE * 4]; 535 Arrays.fill(arrayInV, (short) 42); 536 inV.copyTo(arrayInV); 537 short[] arrayOut = new short[INPUTSIZE * 1]; 538 Arrays.fill(arrayOut, (short) 42); 539 out.copyTo(arrayOut); 540 StringBuilder message = new StringBuilder(); 541 boolean errorFound = false; 542 for (int i = 0; i < INPUTSIZE; i++) { 543 ArgumentsHalfNHalf args = new ArgumentsHalfNHalf(); 544 // Create the appropriate sized arrays in args 545 args.inV = new short[3]; 546 args.inVDouble = new double[3]; 547 // Fill args with the input values 548 for (int j = 0; j < 3 ; j++) { 549 args.inV[j] = arrayInV[i * 4 + j]; 550 args.inVDouble[j] = Float16Utils.convertFloat16ToDouble(args.inV[j]); 551 } 552 Target target = new Target(Target.FunctionType.NATIVE, Target.ReturnType.HALF, relaxed); 553 CoreMathVerifier.computeNativeLength(args, target); 554 555 // Compare the expected outputs to the actual values returned by RS. 556 boolean valid = true; 557 if (!args.out.couldBe(Float16Utils.convertFloat16ToDouble(arrayOut[i]))) { 558 valid = false; 559 } 560 if (!valid) { 561 if (!errorFound) { 562 errorFound = true; 563 for (int j = 0; j < 3 ; j++) { 564 message.append("Input inV: "); 565 appendVariableToMessage(message, arrayInV[i * 4 + j]); 566 message.append("\n"); 567 } 568 message.append("Expected output out: "); 569 appendVariableToMessage(message, args.out); 570 message.append("\n"); 571 message.append("Actual output out: "); 572 appendVariableToMessage(message, arrayOut[i]); 573 message.append("\n"); 574 message.append("Actual output out (in double): "); 575 appendVariableToMessage(message, Float16Utils.convertFloat16ToDouble(arrayOut[i])); 576 if (!args.out.couldBe(Float16Utils.convertFloat16ToDouble(arrayOut[i]))) { 577 message.append(" FAIL"); 578 } 579 message.append("\n"); 580 message.append("Errors at"); 581 } 582 message.append(" ["); 583 message.append(Integer.toString(i)); 584 message.append("]"); 585 } 586 } 587 assertFalse("Incorrect output for checkNativeLengthHalf3Half" + 588 (relaxed ? "_relaxed" : "") + ":\n" + message.toString(), errorFound); 589 } 590 591 private void checkNativeLengthHalf4Half() { 592 Allocation inV = createRandomAllocation(mRS, Element.DataType.FLOAT_16, 4, 0xafbca38753493dbal, false); 593 try { 594 Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_16, 1), INPUTSIZE); 595 script.forEach_testNativeLengthHalf4Half(inV, out); 596 verifyResultsNativeLengthHalf4Half(inV, out, false); 597 out.destroy(); 598 } catch (Exception e) { 599 throw new RSRuntimeException("RenderScript. Can't invoke forEach_testNativeLengthHalf4Half: " + e.toString()); 600 } 601 try { 602 Allocation out = Allocation.createSized(mRS, getElement(mRS, Element.DataType.FLOAT_16, 1), INPUTSIZE); 603 scriptRelaxed.forEach_testNativeLengthHalf4Half(inV, out); 604 verifyResultsNativeLengthHalf4Half(inV, out, true); 605 out.destroy(); 606 } catch (Exception e) { 607 throw new RSRuntimeException("RenderScript. Can't invoke forEach_testNativeLengthHalf4Half: " + e.toString()); 608 } 609 inV.destroy(); 610 } 611 612 private void verifyResultsNativeLengthHalf4Half(Allocation inV, Allocation out, boolean relaxed) { 613 short[] arrayInV = new short[INPUTSIZE * 4]; 614 Arrays.fill(arrayInV, (short) 42); 615 inV.copyTo(arrayInV); 616 short[] arrayOut = new short[INPUTSIZE * 1]; 617 Arrays.fill(arrayOut, (short) 42); 618 out.copyTo(arrayOut); 619 StringBuilder message = new StringBuilder(); 620 boolean errorFound = false; 621 for (int i = 0; i < INPUTSIZE; i++) { 622 ArgumentsHalfNHalf args = new ArgumentsHalfNHalf(); 623 // Create the appropriate sized arrays in args 624 args.inV = new short[4]; 625 args.inVDouble = new double[4]; 626 // Fill args with the input values 627 for (int j = 0; j < 4 ; j++) { 628 args.inV[j] = arrayInV[i * 4 + j]; 629 args.inVDouble[j] = Float16Utils.convertFloat16ToDouble(args.inV[j]); 630 } 631 Target target = new Target(Target.FunctionType.NATIVE, Target.ReturnType.HALF, relaxed); 632 CoreMathVerifier.computeNativeLength(args, target); 633 634 // Compare the expected outputs to the actual values returned by RS. 635 boolean valid = true; 636 if (!args.out.couldBe(Float16Utils.convertFloat16ToDouble(arrayOut[i]))) { 637 valid = false; 638 } 639 if (!valid) { 640 if (!errorFound) { 641 errorFound = true; 642 for (int j = 0; j < 4 ; j++) { 643 message.append("Input inV: "); 644 appendVariableToMessage(message, arrayInV[i * 4 + j]); 645 message.append("\n"); 646 } 647 message.append("Expected output out: "); 648 appendVariableToMessage(message, args.out); 649 message.append("\n"); 650 message.append("Actual output out: "); 651 appendVariableToMessage(message, arrayOut[i]); 652 message.append("\n"); 653 message.append("Actual output out (in double): "); 654 appendVariableToMessage(message, Float16Utils.convertFloat16ToDouble(arrayOut[i])); 655 if (!args.out.couldBe(Float16Utils.convertFloat16ToDouble(arrayOut[i]))) { 656 message.append(" FAIL"); 657 } 658 message.append("\n"); 659 message.append("Errors at"); 660 } 661 message.append(" ["); 662 message.append(Integer.toString(i)); 663 message.append("]"); 664 } 665 } 666 assertFalse("Incorrect output for checkNativeLengthHalf4Half" + 667 (relaxed ? "_relaxed" : "") + ":\n" + message.toString(), errorFound); 668 } 669 670 public void testNativeLength() { 671 checkNativeLengthFloatFloat(); 672 checkNativeLengthFloat2Float(); 673 checkNativeLengthFloat3Float(); 674 checkNativeLengthFloat4Float(); 675 checkNativeLengthHalfHalf(); 676 checkNativeLengthHalf2Half(); 677 checkNativeLengthHalf3Half(); 678 checkNativeLengthHalf4Half(); 679 } 680 } 681
