// Code for unit testing implementation of NativeMovConstRegPatching class void NativeMovConstRegPatching::test() { #ifdef ASSERT ResourceMark rm; CodeBuffer cb("test", 100, 100); MacroAssembler* a = new MacroAssembler(&cb); NativeMovConstRegPatching* nm; uint idx; int offsets[] = { 0x0, 0x7fffffff, 0x80000000, 0xffffffff, 0x20, 4096, 4097, }; VM_Version::allow_all(); AddressLiteral al1(0xaaaabbbb, relocInfo::external_word_type); a->sethi(al1, I3); a->nop(); a->add(I3, al1.low10(), I3); AddressLiteral al2(0xccccdddd, relocInfo::external_word_type); a->sethi(al2, O2); a->nop(); a->add(O2, al2.low10(), O2); nm = nativeMovConstRegPatching_at( cb.insts_begin() ); nm->print(); nm = nativeMovConstRegPatching_at( nm->next_instruction_address() ); for (idx = 0; idx < ARRAY_SIZE(offsets); idx++) { nm->set_data( offsets[idx] ); assert(nm->data() == offsets[idx], "check unit test"); } nm->print(); VM_Version::revert(); #endif // ASSERT }
static void testrotations() { ap::real_2d_array al1; ap::real_2d_array al2; ap::real_2d_array ar1; ap::real_2d_array ar2; ap::real_1d_array cl; ap::real_1d_array sl; ap::real_1d_array cr; ap::real_1d_array sr; ap::real_1d_array w; int m; int n; int maxmn; double t; int pass; int passcount; int i; int j; double err; double maxerr; bool isforward; passcount = 1000; maxerr = 0; for(pass = 1; pass <= passcount; pass++) { // // settings // m = 2+ap::randominteger(50); n = 2+ap::randominteger(50); isforward = ap::randomreal()>0.5; maxmn = ap::maxint(m, n); al1.setbounds(1, m, 1, n); al2.setbounds(1, m, 1, n); ar1.setbounds(1, m, 1, n); ar2.setbounds(1, m, 1, n); cl.setbounds(1, m-1); sl.setbounds(1, m-1); cr.setbounds(1, n-1); sr.setbounds(1, n-1); w.setbounds(1, maxmn); // // matrices and rotaions // for(i = 1; i <= m; i++) { for(j = 1; j <= n; j++) { al1(i,j) = 2*ap::randomreal()-1; al2(i,j) = al1(i,j); ar1(i,j) = al1(i,j); ar2(i,j) = al1(i,j); } } for(i = 1; i <= m-1; i++) { t = 2*ap::pi()*ap::randomreal(); cl(i) = cos(t); sl(i) = sin(t); } for(j = 1; j <= n-1; j++) { t = 2*ap::pi()*ap::randomreal(); cr(j) = cos(t); sr(j) = sin(t); } // // Test left // applyrotationsfromtheleft(isforward, 1, m, 1, n, cl, sl, al1, w); for(j = 1; j <= n; j++) { applyrotationsfromtheleft(isforward, 1, m, j, j, cl, sl, al2, w); } err = 0; for(i = 1; i <= m; i++) { for(j = 1; j <= n; j++) { err = ap::maxreal(err, fabs(al1(i,j)-al2(i,j))); } } maxerr = ap::maxreal(err, maxerr); // // Test right // applyrotationsfromtheright(isforward, 1, m, 1, n, cr, sr, ar1, w); for(i = 1; i <= m; i++) { applyrotationsfromtheright(isforward, i, i, 1, n, cr, sr, ar2, w); } err = 0; for(i = 1; i <= m; i++) { for(j = 1; j <= n; j++) { err = ap::maxreal(err, fabs(ar1(i,j)-ar2(i,j))); } } maxerr = ap::maxreal(err, maxerr); } printf("TESTING ROTATIONS\n"); printf("Pass count %0ld\n", long(passcount)); printf("Error is %5.3le\n", double(maxerr)); }
// Code for unit testing implementation of NativeMovRegMem class void NativeMovRegMem::test() { #ifdef ASSERT ResourceMark rm; CodeBuffer cb("test", 1000, 1000); MacroAssembler* a = new MacroAssembler(&cb); NativeMovRegMem* nm; uint idx = 0; uint idx1; int offsets[] = { 0x0, 0xffffffff, 0x7fffffff, 0x80000000, 4096, 4097, 0x20, 0x4000, }; VM_Version::allow_all(); AddressLiteral al1(0xffffffff, relocInfo::external_word_type); AddressLiteral al2(0xaaaabbbb, relocInfo::external_word_type); a->ldsw( G5, al1.low10(), G4 ); idx++; a->sethi(al2, I3); a->add(I3, al2.low10(), I3); a->ldsw( G5, I3, G4 ); idx++; a->ldsb( G5, al1.low10(), G4 ); idx++; a->sethi(al2, I3); a->add(I3, al2.low10(), I3); a->ldsb( G5, I3, G4 ); idx++; a->ldsh( G5, al1.low10(), G4 ); idx++; a->sethi(al2, I3); a->add(I3, al2.low10(), I3); a->ldsh( G5, I3, G4 ); idx++; a->lduw( G5, al1.low10(), G4 ); idx++; a->sethi(al2, I3); a->add(I3, al2.low10(), I3); a->lduw( G5, I3, G4 ); idx++; a->ldub( G5, al1.low10(), G4 ); idx++; a->sethi(al2, I3); a->add(I3, al2.low10(), I3); a->ldub( G5, I3, G4 ); idx++; a->lduh( G5, al1.low10(), G4 ); idx++; a->sethi(al2, I3); a->add(I3, al2.low10(), I3); a->lduh( G5, I3, G4 ); idx++; a->ldx( G5, al1.low10(), G4 ); idx++; a->sethi(al2, I3); a->add(I3, al2.low10(), I3); a->ldx( G5, I3, G4 ); idx++; a->ldd( G5, al1.low10(), G4 ); idx++; a->sethi(al2, I3); a->add(I3, al2.low10(), I3); a->ldd( G5, I3, G4 ); idx++; a->ldf( FloatRegisterImpl::D, O2, -1, F14 ); idx++; a->sethi(al2, I3); a->add(I3, al2.low10(), I3); a->ldf( FloatRegisterImpl::S, O0, I3, F15 ); idx++; a->stw( G5, G4, al1.low10() ); idx++; a->sethi(al2, I3); a->add(I3, al2.low10(), I3); a->stw( G5, G4, I3 ); idx++; a->stb( G5, G4, al1.low10() ); idx++; a->sethi(al2, I3); a->add(I3, al2.low10(), I3); a->stb( G5, G4, I3 ); idx++; a->sth( G5, G4, al1.low10() ); idx++; a->sethi(al2, I3); a->add(I3, al2.low10(), I3); a->sth( G5, G4, I3 ); idx++; a->stx( G5, G4, al1.low10() ); idx++; a->sethi(al2, I3); a->add(I3, al2.low10(), I3); a->stx( G5, G4, I3 ); idx++; a->std( G5, G4, al1.low10() ); idx++; a->sethi(al2, I3); a->add(I3, al2.low10(), I3); a->std( G5, G4, I3 ); idx++; a->stf( FloatRegisterImpl::S, F18, O2, -1 ); idx++; a->sethi(al2, I3); a->add(I3, al2.low10(), I3); a->stf( FloatRegisterImpl::S, F15, O0, I3 ); idx++; nm = nativeMovRegMem_at( cb.insts_begin() ); nm->print(); nm->set_offset( low10(0) ); nm->print(); nm->add_offset_in_bytes( low10(0xbb) * wordSize ); nm->print(); while (--idx) { nm = nativeMovRegMem_at( nm->next_instruction_address() ); nm->print(); for (idx1 = 0; idx1 < ARRAY_SIZE(offsets); idx1++) { nm->set_offset( nm->is_immediate() ? low10(offsets[idx1]) : offsets[idx1] ); assert(nm->offset() == (nm->is_immediate() ? low10(offsets[idx1]) : offsets[idx1]), "check unit test"); nm->print(); } nm->add_offset_in_bytes( low10(0xbb) * wordSize ); nm->print(); } VM_Version::revert(); #endif // ASSERT }
int main(int argc, char** argv) { #ifdef IO verbose = getenv("PEGASUS_TEST_VERBOSE"); if (verbose) cout << "Test CIMValue. To turn off display, compile with IO undefined\n"; #endif // Test the primitive CIMValue types with test01 test01(Boolean(true)); test01(Boolean(false)); test01(Char16('Z')); test01(Uint8(77)); test01(Sint8(-77)); test01(Sint16(77)); test01(Uint16(-77)); test01(Sint32(77)); test01(Uint32(-77)); test01(Sint64(77)); test01(Uint64(-77)); test01(Real32(1.5)); test01(Real64(55.5)); test01(Uint64(123456789)); test01(Sint64(-123456789)); test01(String("Hello world")); test01(CIMDateTime("19991224120000.000000+360")); test01(CIMObjectPath("//host1:77/root/test:Class1.key1=\"key1Value\",key2=\"key2Value\"")); // Create and populate a declaration context: const CIMNamespaceName NAMESPACE = CIMNamespaceName ("/zzz"); SimpleDeclContext* context = new SimpleDeclContext; context->addQualifierDecl( NAMESPACE, CIMQualifierDecl(CIMName ("counter"), false, CIMScope::PROPERTY)); context->addQualifierDecl( NAMESPACE, CIMQualifierDecl(CIMName ("classcounter"), false, CIMScope::CLASS)); context->addQualifierDecl( NAMESPACE, CIMQualifierDecl(CIMName ("min"), String(), CIMScope::PROPERTY)); context->addQualifierDecl( NAMESPACE, CIMQualifierDecl(CIMName ("max"), String(), CIMScope::PROPERTY)); context->addQualifierDecl(NAMESPACE, CIMQualifierDecl(CIMName ("Description"), String(), CIMScope::PROPERTY)); CIMClass class1(CIMName ("MyClass")); class1 .addProperty(CIMProperty(CIMName ("count"), Uint32(55)) .addQualifier(CIMQualifier(CIMName ("counter"), true)) .addQualifier(CIMQualifier(CIMName ("min"), String("0"))) .addQualifier(CIMQualifier(CIMName ("max"), String("1")))) .addProperty(CIMProperty(CIMName ("message"), String("Hello")) .addQualifier(CIMQualifier(CIMName ("description"), String("My Message")))) .addProperty(CIMProperty(CIMName ("ratio"), Real32(1.5))); Resolver::resolveClass (class1, context, NAMESPACE); context->addClass(NAMESPACE, class1); // Test a CIMObject that is a CIMClass test01(CIMObject(class1)); // Test a CIMObject that is a CIMInstance CIMInstance instance1(CIMName ("MyClass")); instance1.addQualifier(CIMQualifier(CIMName ("classcounter"), true)); instance1.addProperty(CIMProperty(CIMName ("message"), String("Goodbye"))); Resolver::resolveInstance (instance1, context, NAMESPACE, true); test01(CIMObject(instance1)); // Specific test for setting value as a null CIMObject() (see bug 3373). // Confirm that CIMValue() with an uninitialized CIMObject will throw exception. Boolean caught_exception = false; try { CIMObject obj = CIMObject(); CIMValue y(obj); } catch(UninitializedObjectException& e) { caught_exception = true; } assert (caught_exception == true); // Confirm that set() with an uninitialized CIMObject will throw exception. caught_exception = false; try { CIMValue y; y.set(CIMObject()); } catch(UninitializedObjectException& e) { caught_exception = true; } assert (caught_exception == true); // Test CIMValue arrays Array<Uint8> arr1; arr1.append(11); arr1.append(22); arr1.append(23); test02(arr1); Array<Uint16> arr2; arr2.append(333); arr2.append(444); arr2.append(445); test02(arr2); Array<Uint32> arr3; arr3.append(5555); arr3.append(6666); arr3.append(6667); test02(arr3); Array<Uint64> arr4; arr4.append(123456789); arr4.append(987654321); arr4.append(987654322); test02(arr4); Array<Sint8> arr5; arr5.append(-11); arr5.append(-22); arr5.append(-23); test02(arr5); Array<Sint16> arr6; arr6.append(333); arr6.append(444); arr6.append(555); test02(arr6); Array<Sint32> arr7; arr7.append(555); arr7.append(666); arr7.append(777); test02(arr7); Array<Sint64> arr8; arr8.append(-123456789); arr8.append(-987654321); arr8.append(-987654321); test02(arr8); Array<Boolean> arr9; arr9.append(true); arr9.append(false); arr9.append(false); test02(arr9); Array<Real32> arr10; arr10.append(1.55); arr10.append(2.66); arr10.append(3.77); test02(arr10); Array<Real64> arr11; arr11.append(55.55); arr11.append(66.66); arr11.append(77.77); test02(arr11); Array<Char16> arr12; arr12.append('X'); arr12.append('Y'); arr12.append('Z'); test02(arr12); Array<String> arr13; arr13.append("One"); arr13.append("Two"); arr13.append("Three"); test02(arr13); Array<CIMDateTime> arr14; arr14.append(CIMDateTime ("20020130120000.000000+360")); arr14.append(CIMDateTime ("20020201120000.000000+360")); arr14.append(CIMDateTime ("20020202120000.000000+360")); test02(arr14); Array<CIMObjectPath> arr15; arr15.append(CIMObjectPath("//host1:77/root/test:Class1.key1=\"key1Value\",key2=\"key2Value\"")); arr15.append(CIMObjectPath("//host2:88/root/static:Class2.keyA=\"keyAValue\",keyB=\"keyBValue\"")); arr15.append(CIMObjectPath("//host3:99/root/test/static:Class3.keyX=\"keyXValue\",keyY=\"keyYValue\"")); test02(arr15); // Test an array of CIMObjects that are CIMInstances CIMInstance instance2(CIMName ("MyClass")); instance2.addQualifier(CIMQualifier(CIMName ("classcounter"), true)); instance2.addProperty(CIMProperty(CIMName ("message"), String("Adios"))); Resolver::resolveInstance (instance2, context, NAMESPACE, true); CIMInstance instance3(CIMName ("MyClass")); instance3.addQualifier(CIMQualifier(CIMName ("classcounter"), false)); instance3.addProperty(CIMProperty(CIMName ("message"), String("Au Revoir"))); Resolver::resolveInstance (instance3, context, NAMESPACE, true); Array<CIMObject> arr16; arr16.append(CIMObject(instance1)); arr16.append(CIMObject(instance2)); arr16.append(CIMObject(instance3)); test02(arr16); // Specific test for setting value as a null CIMObject() (see bug 3373). // Confirm that CIMValue() with an uninitialized CIMObject in the input // array will throw exception. arr16.append(CIMObject()); caught_exception = false; try { CIMValue y(arr16); } catch(UninitializedObjectException& e) { caught_exception = true; } assert (caught_exception == true); // Confirm that set() with an uninitialized CIMObject in the input // array will throw exception. caught_exception = false; try { CIMValue y; y.set(arr16); } catch(UninitializedObjectException& e) { caught_exception = true; } assert (caught_exception == true); // Calling remaining Array tests.. CIMDateTime D1("19991224120000.000000+100"); Array<CIMDateTime> arrD1(10,D1); CIMDateTime *D2 = new CIMDateTime("19991224120000.000000+100"); Array<CIMDateTime> arrD2(D2,1); test03(arrD1, arrD2, D2, CIMDateTime("19991224120000.000000+100"), CIMDateTime("29991224120000.000000+100")); delete D2; AcceptLanguageElement al1("en-US-mn;;"); Array<AcceptLanguageElement> al_arr1(10,al1); AcceptLanguageElement *al2 = new AcceptLanguageElement("en-US-mn;;"); Array<AcceptLanguageElement> al_arr2(al2,1); test03(al_arr1, al_arr2, al2, AcceptLanguageElement("en-US-mn;;"), AcceptLanguageElement("en-US")); delete al2; CIMName cimname1("yourName"); Array<CIMName> arrcimname1(10,cimname1); CIMName *cimname2 = new CIMName("yourName"); Array<CIMName> arrcimname2(cimname2,1); test03(arrcimname1, arrcimname2, cimname2, CIMName("yourName"), CIMName("myName")); delete cimname2; CIMKeyBinding cimbind1(cimname1, "myKey", CIMKeyBinding::STRING); CIMKeyBinding cimbind2(cimname1, "yourKey", CIMKeyBinding::STRING); Array<CIMKeyBinding> arrcimbind1(10,cimbind1); CIMKeyBinding *cimbind3 = new CIMKeyBinding(cimname1, "myKey", CIMKeyBinding::STRING); Array<CIMKeyBinding> arrcimbind2(cimbind3,1); test03(arrcimbind1, arrcimbind2, cimbind3, cimbind1, cimbind2 ); delete cimbind3; CIMNamespaceName cimnamespace1("root/SampleProvider"); Array<CIMNamespaceName> arrcimnamespace1(10,cimnamespace1); CIMNamespaceName *cimnamespace2 = new CIMNamespaceName("root/SampleProvider"); Array<CIMNamespaceName> arrcimnamespace2(cimnamespace2,1); test03(arrcimnamespace1, arrcimnamespace2, cimnamespace2, CIMNamespaceName("root/SampleProvider"), CIMNamespaceName("root/SampleProvider2")); delete cimnamespace2; Array<Boolean> arrB1(10,true); Boolean *b = new Boolean(true); Array<Boolean> arrB2(b,1); Array<Boolean> arrB3(2); Boolean b1 = true, b2=false; test03(arrB1, arrB2, b, Boolean(true),Boolean(false)); delete b; Array<Real32> arrreal321(10); Real32 creal321(2.5); Array<Real32> arrreal322(10, creal321); Real32 *creal322 = new Real32(2.5); Array<Real32> arrreal323(creal322,1); Array<Real32> arrreal324(arrreal321); test03(arrreal322, arrreal323, creal322,Real32(2.5),Real32(3.5)); delete creal322; Array<Real64> arrreal641(10); Real64 creal641(20000.54321); Array<Real64> arrreal642(10, creal641); Real64 *creal642 = new Real64(20000.54321); Array<Real64> arrreal643(creal642,1); Array<Real64> arrreal644(arrreal641); test03(arrreal642, arrreal643, creal642,Real64(20000.54321), Real64(30000.54321)); delete creal642; Array<Sint16> arrSint161(10); Sint16 cSint161(-2000); Array<Sint16> arrSint162(10, cSint161); Sint16 *cSint162 = new Sint16(-2000); Array<Sint16> arrSint163(cSint162,1); Array<Sint16> arrSint164(arrSint161); test03(arrSint162, arrSint163, cSint162, Sint16(-2000), Sint16(-3000)); delete cSint162; Array<Sint32> arrSint321(10); Sint32 cSint321(-200000000); Array<Sint32> arrSint322(10, cSint321); Sint32 *cSint322 = new Sint32(-200000000); Array<Sint32> arrSint323(cSint322,1); Array<Sint32> arrSint324(arrSint321); test03(arrSint322, arrSint323, cSint322, Sint32(-200000000), Sint32(-300000000)); delete cSint322; Array<Sint64> arrSint641(10); Sint64 cSint641(Sint64(-2000000)*Sint64(10000000) ); Array<Sint64> arrSint642(10, cSint641); Sint64 *cSint642 = new Sint64(Sint64(-2000000)*Sint64(10000000)); Array<Sint64> arrSint643(cSint642,1); Array<Sint64> arrSint644(arrSint641); test03(arrSint642, arrSint643, cSint642,Sint64(-2000000)*Sint64(10000000), Sint64(-3000000)*Sint64(10000000)); delete cSint642; Array<Sint8> arrSint81(10); Sint8 cSint81(-20); Array<Sint8> arrSint82(10, cSint81); Sint8 *cSint82 = new Sint8(-20); Array<Sint8> arrSint83(cSint82,1); Array<Sint8> arrSint84(arrSint81); test03(arrSint82, arrSint83, cSint82, Sint8(-20), Sint8(-22)); delete cSint82; Array<Uint16> arrUint161(10); Uint16 cUint161(200); Array<Uint16> arrUint162(10, cUint161); Uint16 *cUint162 = new Uint16(200); Array<Uint16> arrUint163(cUint162,1); Array<Uint16> arrUint164(arrUint161); test03(arrUint162, arrUint163, cUint162, Uint16(200), Uint16(255)); delete cUint162; Array<Uint32> arrUint321(10); Uint32 cUint321(2000); Array<Uint32> arrUint322(10, cUint321); Uint32 *cUint322 = new Uint32(2000); Array<Uint32> arrUint323(cUint322,1); Array<Uint32> arrUint324(arrUint321); test03(arrUint322, arrUint323, cUint322, Uint32(2000), Uint32(3000)); delete cUint322; Array<Uint64> arrUint641(10); Uint64 cUint641(Uint64(2000000)*Uint64(10000000)); Array<Uint64> arrUint642(10, cUint641); Uint64 *cUint642 = new Uint64(Uint64(2000000)*Uint64(10000000)); Array<Uint64> arrUint643(cUint642,1); Array<Uint64> arrUint644(arrUint641); test03(arrUint642, arrUint643, cUint642,Uint64(2000000)*Uint64(10000000), Uint64(255000)*Uint64(10000000)); delete cUint642; Array<Uint8> arrUint81(10); Uint8 cUint81(200); Array<Uint8> arrUint82(10, cUint81); Uint8 *cUint82 = new Uint8(200); Array<Uint8> arrUint83(cUint82,1); Array<Uint8> arrUint84(arrUint81); test03(arrUint82, arrUint83, cUint82, Uint8(200), Uint8(255)); delete cUint82; Array<Char16> arrChar161(10); Char16 cChar161('Z'); Array<Char16> arrChar162(10, cChar161); Char16 *cChar162 = new Char16('Z'); Array<Char16> arrChar163(cChar162,1); Array<Char16> arrChar164(arrChar161); test03(arrChar162, arrChar163, cChar162, Char16('Z'), Char16('z')); delete cChar162; delete context; cout << argv[0] << " +++++ passed all tests" << endl; return 0; }