void TestSerialization::testDeSerializeLongString() { // Test deserialize { std::istringstream is(serializeLongString(teststring2), std::ios::binary); UASSERT(deSerializeLongString(is) == teststring2); UASSERT(!is.eof()); is.get(); UASSERT(is.eof()); } // Test deserialize an incomplete length specifier { std::istringstream is(mkstr("\x53"), std::ios::binary); EXCEPTION_CHECK(SerializationError, deSerializeLongString(is)); } // Test deserialize a string with incomplete data { std::istringstream is(mkstr("\x00\x00\x00\x05 abc"), std::ios::binary); EXCEPTION_CHECK(SerializationError, deSerializeLongString(is)); } // Test deserialize a string with a length too large { std::istringstream is(mkstr("\xFF\xFF\xFF\xFF blah"), std::ios::binary); EXCEPTION_CHECK(SerializationError, deSerializeLongString(is)); } }
void TestVoxelManipulator::testVoxelManipulator(INodeDefManager *nodedef) { VoxelManipulator v; v.print(infostream, nodedef); infostream << "*** Setting (-1,0,-1)=2 ***" << std::endl; v.setNodeNoRef(v3s16(-1,0,-1), MapNode(t_CONTENT_GRASS)); v.print(infostream, nodedef); UASSERT(v.getNode(v3s16(-1,0,-1)).getContent() == t_CONTENT_GRASS); infostream << "*** Reading from inexistent (0,0,-1) ***" << std::endl; EXCEPTION_CHECK(InvalidPositionException, v.getNode(v3s16(0,0,-1))); v.print(infostream, nodedef); infostream << "*** Adding area ***" << std::endl; VoxelArea a(v3s16(-1,-1,-1), v3s16(1,1,1)); v.addArea(a); v.print(infostream, nodedef); UASSERT(v.getNode(v3s16(-1,0,-1)).getContent() == t_CONTENT_GRASS); EXCEPTION_CHECK(InvalidPositionException, v.getNode(v3s16(0,1,1))); }
void TestSerialization::testDeSerializeWideString() { // Test deserialize { std::istringstream is(serializeWideString(teststring2_w), std::ios::binary); UASSERT(deSerializeWideString(is) == teststring2_w); UASSERT(!is.eof()); is.get(); UASSERT(is.eof()); } // Test deserialize an incomplete length specifier { std::istringstream is(mkstr("\x53"), std::ios::binary); EXCEPTION_CHECK(SerializationError, deSerializeWideString(is)); } // Test deserialize a string with an incomplete character { std::istringstream is(mkstr("\x00\x07\0a\0b\0c\0d\0e\0f\0"), std::ios::binary); EXCEPTION_CHECK(SerializationError, deSerializeWideString(is)); } // Test deserialize a string with incomplete data { std::istringstream is(mkstr("\x00\x08\0a\0b\0c\0d\0e\0f"), std::ios::binary); EXCEPTION_CHECK(SerializationError, deSerializeWideString(is)); } }
JNIEXPORT jboolean JNICALL Java_org_mozilla_jss_ssl_SSLSocket_getCipherPreference( JNIEnv *env, jobject sockObj, jint cipher) { JSSL_SocketData *sock=NULL; SECStatus status; PRBool enabled; /* get the fd */ if( JSSL_getSockData(env, sockObj, &sock) != PR_SUCCESS) { /* exception was thrown */ goto finish; } status = SSL_CipherPrefGet(sock->fd, cipher, &enabled); if( status != SECSuccess ) { char buf[128]; PR_snprintf(buf, 128, "Failed to get preference for cipher 0x%lx\n", cipher); JSSL_throwSSLSocketException(env, buf); goto finish; } finish: EXCEPTION_CHECK(env, sock); return enabled; }
/* * void nativeSetPixels(int[] data, int width, int height, int byteWidth) */ JNIEXPORT void JNICALL Java_com_scriptographer_adm_Image_nativeSetPixels___3IIII(JNIEnv *env, jobject obj, jintArray data, jint width, jint height, jint byteWidth) { try { ADMImageRef image = gEngine->getImageHandle(env, obj); jint len = env->GetArrayLength(data); char *src = (char *) env->GetPrimitiveArrayCritical(data, 0); if (data == NULL) EXCEPTION_CHECK(env); char *dst = (char *) sADMImage->BeginBaseAddressAccess(image); // we're copying int rgb(a) values, so *4: width *= 4; for (int y = 0; y < height; y++) { #ifdef __i386__ // TODO: figure out when ARGB to RGBA switch is needed and when not for (int x = 0; x < width; x += 4) { dst[x + 0] = src[x + 3]; // A dst[x + 1] = src[x + 2]; // R dst[x + 2] = src[x + 1]; // G dst[x + 3] = src[x + 0]; // B } #else memcpy(dst, src, width); #endif src += width; dst += byteWidth; } env->ReleasePrimitiveArrayCritical(data, src, 0); sADMImage->EndBaseAddressAccess(image); } EXCEPTION_CONVERT(env); }
void TestSerialization::testStringLengthLimits() { std::vector<u8> buf; std::string too_long(STRING_MAX_LEN + 1, 'A'); std::string way_too_large(LONG_STRING_MAX_LEN + 1, 'B'); std::wstring too_long_wide(WIDE_STRING_MAX_LEN + 1, L'C'); EXCEPTION_CHECK(SerializationError, putString(&buf, too_long)); putLongString(&buf, too_long); too_long.resize(too_long.size() - 1); putString(&buf, too_long); EXCEPTION_CHECK(SerializationError, putWideString(&buf, too_long_wide)); too_long_wide.resize(too_long_wide.size() - 1); putWideString(&buf, too_long_wide); }
void TestRandom::testPseudoRandomRange() { PseudoRandom pr((int)time(NULL)); EXCEPTION_CHECK(PrngException, pr.range(2000, 6000)); EXCEPTION_CHECK(PrngException, pr.range(5, 1)); for (u32 i = 0; i != 32768; i++) { int min = (pr.next() % 3000) - 500; int max = (pr.next() % 3000) - 500; if (min > max) SWAP(int, min, max); int randval = pr.range(min, max); UASSERT(randval >= min); UASSERT(randval <= max); } }
void TestRandom::testPcgRandomRange() { PcgRandom pr((int)time(NULL)); EXCEPTION_CHECK(PrngException, pr.range(5, 1)); // Regression test for bug 3027 pr.range(pr.RANDOM_MIN, pr.RANDOM_MAX); for (u32 i = 0; i != 32768; i++) { int min = (pr.next() % 3000) - 500; int max = (pr.next() % 3000) - 500; if (min > max) SWAP(int, min, max); int randval = pr.range(min, max); UASSERT(randval >= min); UASSERT(randval <= max); } }
void TestSerialization::testBufReader() { u8 u8_data; u16 u16_data; u32 u32_data; u64 u64_data; s8 s8_data; s16 s16_data; s32 s32_data; s64 s64_data; f32 f32_data, f32_data2, f32_data3, f32_data4; video::SColor scolor_data; v2s16 v2s16_data; v3s16 v3s16_data; v2s32 v2s32_data; v3s32 v3s32_data; v2f v2f_data; v3f v3f_data; std::string string_data; std::wstring widestring_data; std::string longstring_data; u8 raw_data[10] = {0}; BufReader buf(test_serialized_data, sizeof(test_serialized_data)); // Try reading data like normal UASSERT(buf.getU8() == 0x11); UASSERT(buf.getU16() == 0x2233); UASSERT(buf.getU32() == 0x44556677); UASSERT(buf.getU64() == 0x8899AABBCCDDEEFF); UASSERT(buf.getS8() == -128); UASSERT(buf.getS16() == 30000); UASSERT(buf.getS32() == -6); UASSERT(buf.getS64() == -43); UASSERT(buf.getF1000() == 53.534f); UASSERT(buf.getF1000() == -300000.32f); UASSERT(buf.getF1000() == F1000_MIN); UASSERT(buf.getF1000() == F1000_MAX); UASSERT(buf.getString() == "foobar!"); UASSERT(buf.getV2S16() == v2s16(500, 500)); UASSERT(buf.getV3S16() == v3s16(4207, 604, -30)); UASSERT(buf.getV2S32() == v2s32(1920, 1080)); UASSERT(buf.getV3S32() == v3s32(-400, 6400054, 290549855)); UASSERT(buf.getV2F1000() == v2f(500.656f, 350.345f)); UASSERT(buf.getWideString() == L"\x02~woof~\x5455"); UASSERT(buf.getV3F1000() == v3f(500, 10024.2f, -192.54f)); UASSERT(buf.getARGB8() == video::SColor(255, 128, 50, 128)); UASSERT(buf.getLongString() == "some longer string here"); // Verify the offset and data is unchanged after a failed read size_t orig_pos = buf.pos; u32_data = 0; UASSERT(buf.getU32NoEx(&u32_data) == false); UASSERT(buf.pos == orig_pos); UASSERT(u32_data == 0); // Now try the same for a failed string read UASSERT(buf.getStringNoEx(&string_data) == false); UASSERT(buf.pos == orig_pos); UASSERT(string_data == ""); // Now try the same for a failed string read UASSERT(buf.getWideStringNoEx(&widestring_data) == false); UASSERT(buf.pos == orig_pos); UASSERT(widestring_data == L""); UASSERT(buf.getU16() == 0xF00D); UASSERT(buf.remaining() == 0); // Check to make sure these each blow exceptions as they're supposed to EXCEPTION_CHECK(SerializationError, buf.getU8()); EXCEPTION_CHECK(SerializationError, buf.getU16()); EXCEPTION_CHECK(SerializationError, buf.getU32()); EXCEPTION_CHECK(SerializationError, buf.getU64()); EXCEPTION_CHECK(SerializationError, buf.getS8()); EXCEPTION_CHECK(SerializationError, buf.getS16()); EXCEPTION_CHECK(SerializationError, buf.getS32()); EXCEPTION_CHECK(SerializationError, buf.getS64()); EXCEPTION_CHECK(SerializationError, buf.getF1000()); EXCEPTION_CHECK(SerializationError, buf.getARGB8()); EXCEPTION_CHECK(SerializationError, buf.getV2S16()); EXCEPTION_CHECK(SerializationError, buf.getV3S16()); EXCEPTION_CHECK(SerializationError, buf.getV2S32()); EXCEPTION_CHECK(SerializationError, buf.getV3S32()); EXCEPTION_CHECK(SerializationError, buf.getV2F1000()); EXCEPTION_CHECK(SerializationError, buf.getV3F1000()); EXCEPTION_CHECK(SerializationError, buf.getString()); EXCEPTION_CHECK(SerializationError, buf.getWideString()); EXCEPTION_CHECK(SerializationError, buf.getLongString()); EXCEPTION_CHECK(SerializationError, buf.getRawData(raw_data, sizeof(raw_data))); // See if we can skip backwards buf.pos = 5; UASSERT(buf.getRawDataNoEx(raw_data, 3) == true); UASSERT(raw_data[0] == 0x66); UASSERT(raw_data[1] == 0x77); UASSERT(raw_data[2] == 0x88); UASSERT(buf.getU32() == 0x99AABBCC); UASSERT(buf.pos == 12); // Now let's try it all over again using the NoEx variants buf.pos = 0; UASSERT(buf.getU8NoEx(&u8_data)); UASSERT(buf.getU16NoEx(&u16_data)); UASSERT(buf.getU32NoEx(&u32_data)); UASSERT(buf.getU64NoEx(&u64_data)); UASSERT(buf.getS8NoEx(&s8_data)); UASSERT(buf.getS16NoEx(&s16_data)); UASSERT(buf.getS32NoEx(&s32_data)); UASSERT(buf.getS64NoEx(&s64_data)); UASSERT(buf.getF1000NoEx(&f32_data)); UASSERT(buf.getF1000NoEx(&f32_data2)); UASSERT(buf.getF1000NoEx(&f32_data3)); UASSERT(buf.getF1000NoEx(&f32_data4)); UASSERT(buf.getStringNoEx(&string_data)); UASSERT(buf.getV2S16NoEx(&v2s16_data)); UASSERT(buf.getV3S16NoEx(&v3s16_data)); UASSERT(buf.getV2S32NoEx(&v2s32_data)); UASSERT(buf.getV3S32NoEx(&v3s32_data)); UASSERT(buf.getV2F1000NoEx(&v2f_data)); UASSERT(buf.getWideStringNoEx(&widestring_data)); UASSERT(buf.getV3F1000NoEx(&v3f_data)); UASSERT(buf.getARGB8NoEx(&scolor_data)); UASSERT(buf.getLongStringNoEx(&longstring_data)); // and make sure we got the correct data UASSERT(u8_data == 0x11); UASSERT(u16_data == 0x2233); UASSERT(u32_data == 0x44556677); UASSERT(u64_data == 0x8899AABBCCDDEEFF); UASSERT(s8_data == -128); UASSERT(s16_data == 30000); UASSERT(s32_data == -6); UASSERT(s64_data == -43); UASSERT(f32_data == 53.534f); UASSERT(f32_data2 == -300000.32f); UASSERT(f32_data3 == F1000_MIN); UASSERT(f32_data4 == F1000_MAX); UASSERT(string_data == "foobar!"); UASSERT(v2s16_data == v2s16(500, 500)); UASSERT(v3s16_data == v3s16(4207, 604, -30)); UASSERT(v2s32_data == v2s32(1920, 1080)); UASSERT(v3s32_data == v3s32(-400, 6400054, 290549855)); UASSERT(v2f_data == v2f(500.656f, 350.345f)); UASSERT(widestring_data == L"\x02~woof~\x5455"); UASSERT(v3f_data == v3f(500, 10024.2f, -192.54f)); UASSERT(scolor_data == video::SColor(255, 128, 50, 128)); UASSERT(longstring_data == "some longer string here"); UASSERT(buf.remaining() == 2); UASSERT(buf.getRawDataNoEx(raw_data, 3) == false); UASSERT(buf.remaining() == 2); UASSERT(buf.getRawDataNoEx(raw_data, 2) == true); UASSERT(raw_data[0] == 0xF0); UASSERT(raw_data[1] == 0x0D); UASSERT(buf.remaining() == 0); // Make sure no more available data causes a failure UASSERT(!buf.getU8NoEx(&u8_data)); UASSERT(!buf.getU16NoEx(&u16_data)); UASSERT(!buf.getU32NoEx(&u32_data)); UASSERT(!buf.getU64NoEx(&u64_data)); UASSERT(!buf.getS8NoEx(&s8_data)); UASSERT(!buf.getS16NoEx(&s16_data)); UASSERT(!buf.getS32NoEx(&s32_data)); UASSERT(!buf.getS64NoEx(&s64_data)); UASSERT(!buf.getF1000NoEx(&f32_data)); UASSERT(!buf.getARGB8NoEx(&scolor_data)); UASSERT(!buf.getV2S16NoEx(&v2s16_data)); UASSERT(!buf.getV3S16NoEx(&v3s16_data)); UASSERT(!buf.getV2S32NoEx(&v2s32_data)); UASSERT(!buf.getV3S32NoEx(&v3s32_data)); UASSERT(!buf.getV2F1000NoEx(&v2f_data)); UASSERT(!buf.getV3F1000NoEx(&v3f_data)); UASSERT(!buf.getStringNoEx(&string_data)); UASSERT(!buf.getWideStringNoEx(&widestring_data)); UASSERT(!buf.getLongStringNoEx(&longstring_data)); UASSERT(!buf.getRawDataNoEx(raw_data, sizeof(raw_data))); }
JNIEXPORT jint JNICALL Java_org_mozilla_jss_ssl_SSLSocket_socketRead(JNIEnv *env, jobject self, jbyteArray bufBA, jint off, jint len, jint timeout) { JSSL_SocketData *sock = NULL; jbyte *buf = NULL; jint size; PRIntervalTime ivtimeout; PRThread *me; jint nread = -1; size = (*env)->GetArrayLength(env, bufBA); if( off < 0 || len < 0 || (off+len) > size) { JSS_throw(env, INDEX_OUT_OF_BOUNDS_EXCEPTION); goto finish; } buf = (*env)->GetByteArrayElements(env, bufBA, NULL); if( buf == NULL ) { goto finish; } ivtimeout = (timeout > 0) ? PR_MillisecondsToInterval(timeout) : PR_INTERVAL_NO_TIMEOUT; /* get the socket */ if( JSSL_getSockData(env, self, &sock) != PR_SUCCESS ) { goto finish; } /* set the current thread doing the read */ me = PR_GetCurrentThread(); PR_Lock(sock->lock); if ( sock->closePending ) { PR_Unlock(sock->lock); JSSL_throwSSLSocketException(env, "Read operation interrupted"); goto finish; } PR_ASSERT(sock->reader == NULL); sock->reader = me; PR_Unlock(sock->lock); nread = PR_Recv(sock->fd, buf+off, len, 0 /*flags*/, ivtimeout); PR_Lock(sock->lock); PR_ASSERT(sock->reader == me); sock->reader = NULL; PR_Unlock(sock->lock); if( nread < 0 ) { PRErrorCode err = PR_GetError(); if( err == PR_PENDING_INTERRUPT_ERROR ) { #ifdef WINNT /* Clean up after PR_interrupt called by abortReadWrite. */ PR_NT_CancelIo(sock->fd); #endif JSSL_throwSSLSocketException(env, "Read operation interrupted"); } else if( err == PR_IO_TIMEOUT_ERROR ) { #ifdef WINNT /* * if timeout was set, and the PR_Recv timed out, * then cancel the I/O on the socket, otherwise PR_Recv() * will always return PR_IO_PENDING_ERROR on subsequent * calls */ PR_NT_CancelIo(sock->fd); #endif JSSL_throwSSLSocketException(env, "Operation timed out"); } else { JSSL_throwSSLSocketException(env, "Error reading from socket"); } goto finish; } if( nread == 0 ) { /* EOF in Java is -1 */ nread = -1; } finish: EXCEPTION_CHECK(env, sock) (*env)->ReleaseByteArrayElements(env, bufBA, buf, (nread>0) ? 0 /*copy and free*/ : JNI_ABORT /*free, no copy*/); return nread; }
void Run() { /* VoxelArea */ VoxelArea a(v3s16(-1,-1,-1), v3s16(1,1,1)); assert(a.index(0,0,0) == 1*3*3 + 1*3 + 1); assert(a.index(-1,-1,-1) == 0); VoxelArea c(v3s16(-2,-2,-2), v3s16(2,2,2)); // An area that is 1 bigger in x+ and z- VoxelArea d(v3s16(-2,-2,-3), v3s16(3,2,2)); core::list<VoxelArea> aa; d.diff(c, aa); // Correct results core::array<VoxelArea> results; results.push_back(VoxelArea(v3s16(-2,-2,-3),v3s16(3,2,-3))); results.push_back(VoxelArea(v3s16(3,-2,-2),v3s16(3,2,2))); assert(aa.size() == results.size()); infostream<<"Result of diff:"<<std::endl; for(core::list<VoxelArea>::Iterator i = aa.begin(); i != aa.end(); i++) { i->print(infostream); infostream<<std::endl; s32 j = results.linear_search(*i); assert(j != -1); results.erase(j, 1); } /* VoxelManipulator */ VoxelManipulator v; v.print(infostream); infostream<<"*** Setting (-1,0,-1)=2 ***"<<std::endl; v.setNodeNoRef(v3s16(-1,0,-1), MapNode(2)); v.print(infostream); assert(v.getNode(v3s16(-1,0,-1)).getContent() == 2); infostream<<"*** Reading from inexistent (0,0,-1) ***"<<std::endl; EXCEPTION_CHECK(InvalidPositionException, v.getNode(v3s16(0,0,-1))); v.print(infostream); infostream<<"*** Adding area ***"<<std::endl; v.addArea(a); v.print(infostream); assert(v.getNode(v3s16(-1,0,-1)).getContent() == 2); EXCEPTION_CHECK(InvalidPositionException, v.getNode(v3s16(0,1,1))); #if 0 /* Water stuff */ v.clear(); const char *content = "#...###### " "#...##..## " "#........ .." "############" "#...###### " "#...##..## " "#........# " "############" ; v3s16 size(12, 4, 2); VoxelArea area(v3s16(0,0,0), size-v3s16(1,1,1)); const char *p = content; for(s16 z=0; z<size.Z; z++) for(s16 y=size.Y-1; y>=0; y--) for(s16 x=0; x<size.X; x++) { MapNode n; //n.pressure = size.Y - y; if(*p == '#') n.setContent(CONTENT_STONE); else if(*p == '.') n.setContent(CONTENT_WATER); else if(*p == ' ') n.setContent(CONTENT_AIR); else assert(0); v.setNode(v3s16(x,y,z), n); p++; } v.print(infostream, VOXELPRINT_WATERPRESSURE); core::map<v3s16, u8> active_nodes; v.updateAreaWaterPressure(area, active_nodes); v.print(infostream, VOXELPRINT_WATERPRESSURE); //s16 highest_y = -32768; /* NOTE: These are commented out because this behaviour is changed all the time */ //assert(v.getWaterPressure(v3s16(7, 1, 1), highest_y, 0) == -1); //assert(highest_y == 3); /*assert(v.getWaterPressure(v3s16(7, 1, 1), highest_y, 0) == 3); //assert(highest_y == 3);*/ active_nodes.clear(); active_nodes[v3s16(9,1,0)] = 1; //v.flowWater(active_nodes, 0, true, 1000); v.flowWater(active_nodes, 0, false, 1000); infostream<<"Final result of flowWater:"<<std::endl; v.print(infostream, VOXELPRINT_WATERPRESSURE); #endif //assert(0); }