From 5a41b1b5380679afff2d42bfe71c146f12bb6185 Mon Sep 17 00:00:00 2001 From: winlin Date: Sat, 5 Jul 2014 21:22:20 +0800 Subject: [PATCH] finish kernel utest. to 0.9.149 --- trunk/src/app/srs_app_avc_aac.cpp | 18 +- trunk/src/core/srs_core.hpp | 2 +- trunk/src/kernel/srs_kernel_error.hpp | 2 +- trunk/src/kernel/srs_kernel_stream.cpp | 52 +- trunk/src/kernel/srs_kernel_stream.hpp | 53 +- trunk/src/libs/srs_librtmp.cpp | 2 +- trunk/src/rtmp/srs_protocol_rtmp_stack.cpp | 4 +- trunk/src/utest/srs_utest_amf0.cpp | 92 ++-- trunk/src/utest/srs_utest_kernel.cpp | 563 ++++++++++++++++++++- 9 files changed, 679 insertions(+), 109 deletions(-) diff --git a/trunk/src/app/srs_app_avc_aac.cpp b/trunk/src/app/srs_app_avc_aac.cpp index 6ad4e816d..a4bbd93fb 100644 --- a/trunk/src/app/srs_app_avc_aac.cpp +++ b/trunk/src/app/srs_app_avc_aac.cpp @@ -204,11 +204,11 @@ int SrsAvcAacCodec::audio_aac_demux(int8_t* data, int size, SrsCodecSample* samp if (aac_packet_type == SrsCodecAudioTypeSequenceHeader) { // AudioSpecificConfig // 1.6.2.1 AudioSpecificConfig, in aac-mp4a-format-ISO_IEC_14496-3+2001.pdf, page 33. - aac_extra_size = stream->left(); + aac_extra_size = stream->size() - stream->pos(); if (aac_extra_size > 0) { srs_freep(aac_extra_data); aac_extra_data = new char[aac_extra_size]; - memcpy(aac_extra_data, stream->current(), aac_extra_size); + memcpy(aac_extra_data, stream->data() + stream->pos(), aac_extra_size); } // only need to decode the first 2bytes: @@ -253,7 +253,7 @@ int SrsAvcAacCodec::audio_aac_demux(int8_t* data, int size, SrsCodecSample* samp // Raw AAC frame data in UI8 [] // 6.3 Raw Data, aac-iso-13818-7.pdf, page 28 - if ((ret = sample->add_sample(stream->current(), stream->left())) != ERROR_SUCCESS) { + if ((ret = sample->add_sample(stream->data() + stream->pos(), stream->size() - stream->pos())) != ERROR_SUCCESS) { srs_error("hls add audio sample failed. ret=%d", ret); return ret; } @@ -318,11 +318,11 @@ int SrsAvcAacCodec::video_avc_demux(int8_t* data, int size, SrsCodecSample* samp if (avc_packet_type == SrsCodecVideoAVCTypeSequenceHeader) { // AVCDecoderConfigurationRecord // 5.2.4.1.1 Syntax, H.264-AVC-ISO_IEC_14496-15.pdf, page 16 - avc_extra_size = stream->left(); + avc_extra_size = stream->size() - stream->pos(); if (avc_extra_size > 0) { srs_freep(avc_extra_data); avc_extra_data = new char[avc_extra_size]; - memcpy(avc_extra_data, stream->current(), avc_extra_size); + memcpy(avc_extra_data, stream->data() + stream->pos(), avc_extra_size); } if (!stream->require(6)) { @@ -367,7 +367,7 @@ int SrsAvcAacCodec::video_avc_demux(int8_t* data, int size, SrsCodecSample* samp if (sequenceParameterSetLength > 0) { srs_freep(sequenceParameterSetNALUnit); sequenceParameterSetNALUnit = new char[sequenceParameterSetLength]; - memcpy(sequenceParameterSetNALUnit, stream->current(), sequenceParameterSetLength); + memcpy(sequenceParameterSetNALUnit, stream->data() + stream->pos(), sequenceParameterSetLength); stream->skip(sequenceParameterSetLength); } // 1 pps @@ -397,7 +397,7 @@ int SrsAvcAacCodec::video_avc_demux(int8_t* data, int size, SrsCodecSample* samp if (pictureParameterSetLength > 0) { srs_freep(pictureParameterSetNALUnit); pictureParameterSetNALUnit = new char[pictureParameterSetLength]; - memcpy(pictureParameterSetNALUnit, stream->current(), pictureParameterSetLength); + memcpy(pictureParameterSetNALUnit, stream->data() + stream->pos(), pictureParameterSetLength); stream->skip(pictureParameterSetLength); } } else if (avc_packet_type == SrsCodecVideoAVCTypeNALU){ @@ -410,7 +410,7 @@ int SrsAvcAacCodec::video_avc_demux(int8_t* data, int size, SrsCodecSample* samp // One or more NALUs (Full frames are required) // 5.3.4.2.1 Syntax, H.264-AVC-ISO_IEC_14496-15.pdf, page 20 - int PictureLength = stream->left(); + int PictureLength = stream->size() - stream->pos(); for (int i = 0; i < PictureLength;) { if (!stream->require(NAL_unit_length + 1)) { ret = ERROR_HLS_DECODE_ERROR; @@ -434,7 +434,7 @@ int SrsAvcAacCodec::video_avc_demux(int8_t* data, int size, SrsCodecSample* samp return ret; } // 7.3.1 NAL unit syntax, H.264-AVC-ISO_IEC_14496-10.pdf, page 44. - if ((ret = sample->add_sample(stream->current(), NALUnitLength)) != ERROR_SUCCESS) { + if ((ret = sample->add_sample(stream->data() + stream->pos(), NALUnitLength)) != ERROR_SUCCESS) { srs_error("hls add video sample failed. ret=%d", ret); return ret; } diff --git a/trunk/src/core/srs_core.hpp b/trunk/src/core/srs_core.hpp index 40257205a..dbdfadc10 100644 --- a/trunk/src/core/srs_core.hpp +++ b/trunk/src/core/srs_core.hpp @@ -31,7 +31,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // current release version #define VERSION_MAJOR "0" #define VERSION_MINOR "9" -#define VERSION_REVISION "148" +#define VERSION_REVISION "149" #define RTMP_SIG_SRS_VERSION VERSION_MAJOR"."VERSION_MINOR"."VERSION_REVISION // server info. #define RTMP_SIG_SRS_KEY "SRS" diff --git a/trunk/src/kernel/srs_kernel_error.hpp b/trunk/src/kernel/srs_kernel_error.hpp index 7a195d5e6..3fcb6b452 100644 --- a/trunk/src/kernel/srs_kernel_error.hpp +++ b/trunk/src/kernel/srs_kernel_error.hpp @@ -87,7 +87,6 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // aggregate message parse failed. #define ERROR_RTMP_AGGREGATE 324 -#define ERROR_SYSTEM_STREAM_INIT 400 #define ERROR_SYSTEM_PACKET_INVALID 401 #define ERROR_SYSTEM_CLIENT_INVALID 402 #define ERROR_SYSTEM_ASSERT_FAILED 403 @@ -190,6 +189,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #define ERROR_KERNEL_FLV_HEADER 900 #define ERROR_KERNEL_FLV_STREAM_CLOSED 901 +#define ERROR_KERNEL_STREAM_INIT 902 // system control message, // not an error, but special control logic. diff --git a/trunk/src/kernel/srs_kernel_stream.cpp b/trunk/src/kernel/srs_kernel_stream.cpp index e9a388599..580eace1b 100644 --- a/trunk/src/kernel/srs_kernel_stream.cpp +++ b/trunk/src/kernel/srs_kernel_stream.cpp @@ -31,8 +31,8 @@ using namespace std; SrsStream::SrsStream() { - p = bytes = NULL; - size = 0; + p = _bytes = NULL; + _size = 0; // TODO: support both little and big endian. srs_assert(srs_is_little_endian()); @@ -42,61 +42,61 @@ SrsStream::~SrsStream() { } -int SrsStream::initialize(char* _bytes, int _size) +int SrsStream::initialize(char* bytes, int size) { int ret = ERROR_SUCCESS; - if (!_bytes) { - ret = ERROR_SYSTEM_STREAM_INIT; + if (!bytes) { + ret = ERROR_KERNEL_STREAM_INIT; srs_error("stream param bytes must not be NULL. ret=%d", ret); return ret; } - if (_size <= 0) { - ret = ERROR_SYSTEM_STREAM_INIT; + if (size <= 0) { + ret = ERROR_KERNEL_STREAM_INIT; srs_error("stream param size must be positive. ret=%d", ret); return ret; } - size = _size; - p = bytes = _bytes; + _size = size; + p = _bytes = bytes; + srs_info("init stream ok, size=%d", size); return ret; } -void SrsStream::reset() +char* SrsStream::data() { - p = bytes; + return _bytes; } -bool SrsStream::empty() -{ - return !p || !bytes || (p >= bytes + size); -} - -bool SrsStream::require(int required_size) +int SrsStream::size() { - return !empty() && (required_size <= bytes + size - p); + return _size; } -void SrsStream::skip(int size) +int SrsStream::pos() { - p += size; + return p - _bytes; } -int SrsStream::pos() +bool SrsStream::empty() { - return p - bytes; + return !_bytes || (p >= _bytes + _size); } -int SrsStream::left() +bool SrsStream::require(int required_size) { - return size - pos(); + srs_assert(required_size > 0); + + return required_size <= _size - (p - _bytes); } -char* SrsStream::current() +void SrsStream::skip(int size) { - return p; + srs_assert(p); + + p += size; } int8_t SrsStream::read_1bytes() diff --git a/trunk/src/kernel/srs_kernel_stream.hpp b/trunk/src/kernel/srs_kernel_stream.hpp index 4f36b8f31..fd7d80136 100644 --- a/trunk/src/kernel/srs_kernel_stream.hpp +++ b/trunk/src/kernel/srs_kernel_stream.hpp @@ -33,52 +33,67 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include #include +/** +* bytes utility, used to: +* convert basic types to bytes, +* build basic types from bytes. +*/ class SrsStream { private: char* p; char* pp; - char* bytes; - int size; + char* _bytes; + int _size; public: SrsStream(); virtual ~SrsStream(); public: /** * initialize the stream from bytes. - * @_bytes, must not be NULL, or return error. - * @_size, must be positive, or return error. - * @remark, stream never free the _bytes, user must free it. + * @bytes, the bytes to convert from/to basic types. + * @size, the size of bytes. + * @remark, stream never free the bytes, user must free it. + * @remark, return error when bytes NULL. + * @remark, return error when size is not positive. + */ + virtual int initialize(char* bytes, int size); +// get the status of stream +public: + /** + * get data of stream, set by initialize. + * current bytes = data() + pos() */ - virtual int initialize(char* _bytes, int _size); + virtual char* data(); /** - * reset the position to beginning. + * the total stream size, set by initialize. + * left bytes = size() - pos(). */ - virtual void reset(); + virtual int size(); + /** + * tell the current pos. + */ + virtual int pos(); /** * whether stream is empty. - * if empty, never read or write. + * if empty, user should never read or write. */ virtual bool empty(); /** * whether required size is ok. * @return true if stream can read/write specified required_size bytes. + * @remark assert required_size positive. */ virtual bool require(int required_size); +// to change stream. +public: /** * to skip some size. - * @size can be any value. positive to forward; nagetive to backward. + * @param size can be any value. positive to forward; nagetive to backward. + * @remark to skip(pos()) to reset stream. + * @remark assert initialized, the data() not NULL. */ virtual void skip(int size); - /** - * tell the current pos. - */ - virtual int pos(); - /** - * left size of bytes. - */ - virtual int left(); - virtual char* current(); public: /** * get 1bytes char from stream. diff --git a/trunk/src/libs/srs_librtmp.cpp b/trunk/src/libs/srs_librtmp.cpp index baecfebb8..46ec07aef 100644 --- a/trunk/src/libs/srs_librtmp.cpp +++ b/trunk/src/libs/srs_librtmp.cpp @@ -659,7 +659,7 @@ srs_amf0_t srs_amf0_parse(char* data, int size, int* nparsed) return amf0; } - stream.reset(); + stream.skip(-1 * stream.pos()); if ((ret = any->read(&stream)) != ERROR_SUCCESS) { srs_freep(any); return amf0; diff --git a/trunk/src/rtmp/srs_protocol_rtmp_stack.cpp b/trunk/src/rtmp/srs_protocol_rtmp_stack.cpp index b41cae081..678d4c061 100644 --- a/trunk/src/rtmp/srs_protocol_rtmp_stack.cpp +++ b/trunk/src/rtmp/srs_protocol_rtmp_stack.cpp @@ -601,7 +601,7 @@ int SrsProtocol::do_decode_message(SrsMessageHeader& header, SrsStream* stream, srs_verbose("AMF0/AMF3 command id, transcationId=%.2f", transactionId); // reset stream, for header read completed. - stream->reset(); + stream->skip(-1 * stream->pos()); if (header.is_amf3_command()) { stream->skip(1); } @@ -638,7 +638,7 @@ int SrsProtocol::do_decode_message(SrsMessageHeader& header, SrsStream* stream, } // reset to zero(amf3 to 1) to restart decode. - stream->reset(); + stream->skip(-1 * stream->pos()); if (header.is_amf3_command()) { stream->skip(1); } diff --git a/trunk/src/utest/srs_utest_amf0.cpp b/trunk/src/utest/srs_utest_amf0.cpp index 9770f1ffc..ed6fb5a55 100644 --- a/trunk/src/utest/srs_utest_amf0.cpp +++ b/trunk/src/utest/srs_utest_amf0.cpp @@ -521,8 +521,8 @@ VOID TEST(AMF0Test, ApiAnyIO) // object eof if (true) { - s.reset(); - s.current()[2] = 0x09; + s.skip(-1 * s.pos()); + (s.data() + s.pos())[2] = 0x09; o = SrsAmf0Any::object_eof(); SrsAutoFree(SrsAmf0Any, o); @@ -531,12 +531,12 @@ VOID TEST(AMF0Test, ApiAnyIO) EXPECT_EQ(o->total_size(), s.pos()); EXPECT_EQ(3, s.pos()); - s.reset(); - s.current()[0] = 0x01; + s.skip(-1 * s.pos()); + (s.data() + s.pos())[0] = 0x01; EXPECT_NE(ERROR_SUCCESS, o->read(&s)); } if (true) { - s.reset(); + s.skip(-1 * s.pos()); o = SrsAmf0Any::object_eof(); SrsAutoFree(SrsAmf0Any, o); @@ -551,7 +551,7 @@ VOID TEST(AMF0Test, ApiAnyIO) // string if (true) { - s.reset(); + s.skip(-1 * s.pos()); o = SrsAmf0Any::str("winlin"); SrsAutoFree(SrsAmf0Any, o); @@ -559,14 +559,14 @@ VOID TEST(AMF0Test, ApiAnyIO) EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(o->total_size(), s.pos()); - s.reset(); + s.skip(-1 * s.pos()); EXPECT_EQ(2, s.read_1bytes()); EXPECT_EQ(6, s.read_2bytes()); - EXPECT_EQ('w', s.current()[0]); - EXPECT_EQ('n', s.current()[5]); + EXPECT_EQ('w', (s.data() + s.pos())[0]); + EXPECT_EQ('n', (s.data() + s.pos())[5]); - s.reset(); - s.current()[3] = 'x'; + s.skip(-1 * s.pos()); + (s.data() + s.pos())[3] = 'x'; EXPECT_EQ(ERROR_SUCCESS, o->read(&s)); EXPECT_EQ(o->total_size(), s.pos()); EXPECT_STREQ("xinlin", o->to_str().c_str()); @@ -574,7 +574,7 @@ VOID TEST(AMF0Test, ApiAnyIO) // number if (true) { - s.reset(); + s.skip(-1 * s.pos()); o = SrsAmf0Any::number(10); SrsAutoFree(SrsAmf0Any, o); @@ -582,10 +582,10 @@ VOID TEST(AMF0Test, ApiAnyIO) EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(o->total_size(), s.pos()); - s.reset(); + s.skip(-1 * s.pos()); EXPECT_EQ(0, s.read_1bytes()); - s.reset(); + s.skip(-1 * s.pos()); EXPECT_EQ(ERROR_SUCCESS, o->read(&s)); EXPECT_EQ(o->total_size(), s.pos()); EXPECT_DOUBLE_EQ(10, o->to_number()); @@ -593,7 +593,7 @@ VOID TEST(AMF0Test, ApiAnyIO) // boolean if (true) { - s.reset(); + s.skip(-1 * s.pos()); o = SrsAmf0Any::boolean(true); SrsAutoFree(SrsAmf0Any, o); @@ -601,16 +601,16 @@ VOID TEST(AMF0Test, ApiAnyIO) EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(o->total_size(), s.pos()); - s.reset(); + s.skip(-1 * s.pos()); EXPECT_EQ(1, s.read_1bytes()); - s.reset(); + s.skip(-1 * s.pos()); EXPECT_EQ(ERROR_SUCCESS, o->read(&s)); EXPECT_EQ(o->total_size(), s.pos()); EXPECT_TRUE(o->to_boolean()); } if (true) { - s.reset(); + s.skip(-1 * s.pos()); o = SrsAmf0Any::boolean(false); SrsAutoFree(SrsAmf0Any, o); @@ -618,10 +618,10 @@ VOID TEST(AMF0Test, ApiAnyIO) EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(o->total_size(), s.pos()); - s.reset(); + s.skip(-1 * s.pos()); EXPECT_EQ(1, s.read_1bytes()); - s.reset(); + s.skip(-1 * s.pos()); EXPECT_EQ(ERROR_SUCCESS, o->read(&s)); EXPECT_EQ(o->total_size(), s.pos()); EXPECT_FALSE(o->to_boolean()); @@ -629,7 +629,7 @@ VOID TEST(AMF0Test, ApiAnyIO) // null if (true) { - s.reset(); + s.skip(-1 * s.pos()); o = SrsAmf0Any::null(); SrsAutoFree(SrsAmf0Any, o); @@ -637,10 +637,10 @@ VOID TEST(AMF0Test, ApiAnyIO) EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(o->total_size(), s.pos()); - s.reset(); + s.skip(-1 * s.pos()); EXPECT_EQ(5, s.read_1bytes()); - s.reset(); + s.skip(-1 * s.pos()); EXPECT_EQ(ERROR_SUCCESS, o->read(&s)); EXPECT_EQ(o->total_size(), s.pos()); EXPECT_TRUE(o->is_null()); @@ -648,7 +648,7 @@ VOID TEST(AMF0Test, ApiAnyIO) // undefined if (true) { - s.reset(); + s.skip(-1 * s.pos()); o = SrsAmf0Any::undefined(); SrsAutoFree(SrsAmf0Any, o); @@ -656,10 +656,10 @@ VOID TEST(AMF0Test, ApiAnyIO) EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(o->total_size(), s.pos()); - s.reset(); + s.skip(-1 * s.pos()); EXPECT_EQ(6, s.read_1bytes()); - s.reset(); + s.skip(-1 * s.pos()); EXPECT_EQ(ERROR_SUCCESS, o->read(&s)); EXPECT_EQ(o->total_size(), s.pos()); EXPECT_TRUE(o->is_undefined()); @@ -667,7 +667,7 @@ VOID TEST(AMF0Test, ApiAnyIO) // any: string if (true) { - s.reset(); + s.skip(-1 * s.pos()); o = SrsAmf0Any::str("winlin"); SrsAutoFree(SrsAmf0Any, o); @@ -675,7 +675,7 @@ VOID TEST(AMF0Test, ApiAnyIO) EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(o->total_size(), s.pos()); - s.reset(); + s.skip(-1 * s.pos()); SrsAmf0Any* po = NULL; EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po)); @@ -687,7 +687,7 @@ VOID TEST(AMF0Test, ApiAnyIO) // any: number if (true) { - s.reset(); + s.skip(-1 * s.pos()); o = SrsAmf0Any::number(10); SrsAutoFree(SrsAmf0Any, o); @@ -695,7 +695,7 @@ VOID TEST(AMF0Test, ApiAnyIO) EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(o->total_size(), s.pos()); - s.reset(); + s.skip(-1 * s.pos()); SrsAmf0Any* po = NULL; EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po)); @@ -707,7 +707,7 @@ VOID TEST(AMF0Test, ApiAnyIO) // any: boolean if (true) { - s.reset(); + s.skip(-1 * s.pos()); o = SrsAmf0Any::boolean(true); SrsAutoFree(SrsAmf0Any, o); @@ -715,7 +715,7 @@ VOID TEST(AMF0Test, ApiAnyIO) EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(o->total_size(), s.pos()); - s.reset(); + s.skip(-1 * s.pos()); SrsAmf0Any* po = NULL; EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po)); @@ -727,7 +727,7 @@ VOID TEST(AMF0Test, ApiAnyIO) // any: null if (true) { - s.reset(); + s.skip(-1 * s.pos()); o = SrsAmf0Any::null(); SrsAutoFree(SrsAmf0Any, o); @@ -735,7 +735,7 @@ VOID TEST(AMF0Test, ApiAnyIO) EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(o->total_size(), s.pos()); - s.reset(); + s.skip(-1 * s.pos()); SrsAmf0Any* po = NULL; EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po)); @@ -746,7 +746,7 @@ VOID TEST(AMF0Test, ApiAnyIO) // any: undefined if (true) { - s.reset(); + s.skip(-1 * s.pos()); o = SrsAmf0Any::undefined(); SrsAutoFree(SrsAmf0Any, o); @@ -754,7 +754,7 @@ VOID TEST(AMF0Test, ApiAnyIO) EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(o->total_size(), s.pos()); - s.reset(); + s.skip(-1 * s.pos()); SrsAmf0Any* po = NULL; EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po)); @@ -765,7 +765,7 @@ VOID TEST(AMF0Test, ApiAnyIO) // mixed any if (true) { - s.reset(); + s.skip(-1 * s.pos()); o = SrsAmf0Any::str("winlin"); EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); @@ -787,7 +787,7 @@ VOID TEST(AMF0Test, ApiAnyIO) EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); srs_freep(o); - s.reset(); + s.skip(-1 * s.pos()); SrsAmf0Any* po = NULL; EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po)); @@ -831,8 +831,8 @@ VOID TEST(AMF0Test, ApiAnyAssert) // read any if (true) { - s.reset(); - s.current()[0] = 0x12; + s.skip(-1 * s.pos()); + (s.data() + s.pos())[0] = 0x12; EXPECT_NE(ERROR_SUCCESS, srs_amf0_read_any(&s, &o)); EXPECT_TRUE(NULL == o); srs_freep(o); @@ -884,7 +884,7 @@ VOID TEST(AMF0Test, ApiAnyAssert) if (true) { o = SrsAmf0Any::object(); SrsAutoFree(SrsAmf0Any, o); - s.reset(); + s.skip(-1 * s.pos()); EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(1+3, s.pos()); } @@ -893,7 +893,7 @@ VOID TEST(AMF0Test, ApiAnyAssert) if (true) { o = SrsAmf0Any::ecma_array(); SrsAutoFree(SrsAmf0Any, o); - s.reset(); + s.skip(-1 * s.pos()); EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(1+4+3, s.pos()); } @@ -902,7 +902,7 @@ VOID TEST(AMF0Test, ApiAnyAssert) if (true) { o = SrsAmf0Any::strict_array(); SrsAutoFree(SrsAmf0Any, o); - s.reset(); + s.skip(-1 * s.pos()); EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(1+4, s.pos()); } @@ -1111,11 +1111,11 @@ VOID TEST(AMF0Test, ApiStrictArray) o = SrsAmf0Any::strict_array(); SrsAutoFree(SrsAmf0StrictArray, o); - s.reset(); + s.skip(-1 * s.pos()); EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(5, s.pos()); - s.reset(); + s.skip(-1 * s.pos()); EXPECT_EQ(0x0a, s.read_1bytes()); EXPECT_EQ(0x00, s.read_4bytes()); } @@ -1126,7 +1126,7 @@ VOID TEST(AMF0Test, ApiStrictArray) o->append(SrsAmf0Any::number(0)); - s.reset(); + s.skip(-1 * s.pos()); EXPECT_EQ(ERROR_SUCCESS, o->write(&s)); EXPECT_EQ(5 + SrsAmf0Size::number(), s.pos()); } diff --git a/trunk/src/utest/srs_utest_kernel.cpp b/trunk/src/utest/srs_utest_kernel.cpp index 18c8d51ce..438717854 100644 --- a/trunk/src/utest/srs_utest_kernel.cpp +++ b/trunk/src/utest/srs_utest_kernel.cpp @@ -29,6 +29,7 @@ using namespace std; #include #include #include +#include #define MAX_MOCK_DATA_SIZE 1024 * 1024 @@ -198,7 +199,7 @@ int MockBufferReader::read(void* buf, size_t size, ssize_t* nread) return ERROR_SUCCESS; } -VOID TEST(BufferTest, DefaultObject) +VOID TEST(KernelBufferTest, DefaultObject) { SrsBuffer b; @@ -206,7 +207,7 @@ VOID TEST(BufferTest, DefaultObject) EXPECT_EQ(NULL, b.bytes()); } -VOID TEST(BufferTest, AppendBytes) +VOID TEST(KernelBufferTest, AppendBytes) { SrsBuffer b; @@ -226,7 +227,7 @@ VOID TEST(BufferTest, AppendBytes) EXPECT_EQ('n', b.bytes()[11]); } -VOID TEST(BufferTest, EraseBytes) +VOID TEST(KernelBufferTest, EraseBytes) { SrsBuffer b; @@ -262,7 +263,7 @@ VOID TEST(BufferTest, EraseBytes) EXPECT_EQ(0, b.length()); } -VOID TEST(BufferTest, Grow) +VOID TEST(KernelBufferTest, Grow) { SrsBuffer b; MockBufferReader r("winlin"); @@ -954,3 +955,557 @@ VOID TEST(KernelFlvTest, FlvVSDecoderSeek) EXPECT_TRUE(ERROR_SUCCESS == dec.lseek(5)); EXPECT_TRUE(5 == fs.offset); } + +/** +* test the stream utility, bytes from/to basic types. +*/ +VOID TEST(KernelStreamTest, StreamInitialize) +{ + SrsStream s; + char data[1024]; + + EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024)); + EXPECT_TRUE(ERROR_SUCCESS != s.initialize(NULL, 1024)); + EXPECT_TRUE(ERROR_SUCCESS != s.initialize(data, 0)); + EXPECT_TRUE(ERROR_SUCCESS != s.initialize(data, -1)); +} + +/** +* test the stream utility, access data +*/ +VOID TEST(KernelStreamTest, StreamData) +{ + SrsStream s; + char data[1024]; + + EXPECT_TRUE(s.data() == NULL); + EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024)); + EXPECT_TRUE(s.data() == data); +} + +/** +* test the stream utility, access size +*/ +VOID TEST(KernelStreamTest, StreamSize) +{ + SrsStream s; + char data[1024]; + + EXPECT_TRUE(s.size() == 0); + EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024)); + EXPECT_TRUE(s.size() == 1024); +} + +/** +* test the stream utility, access pos +*/ +VOID TEST(KernelStreamTest, StreamPos) +{ + SrsStream s; + char data[1024]; + + EXPECT_TRUE(s.pos() == 0); + EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024)); + EXPECT_TRUE(s.pos() == 0); + + s.read_bytes(data, 1024); + EXPECT_TRUE(s.pos() == 1024); +} + +/** +* test the stream utility, access empty +*/ +VOID TEST(KernelStreamTest, StreamEmpty) +{ + SrsStream s; + char data[1024]; + + EXPECT_TRUE(s.empty()); + EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024)); + EXPECT_FALSE(s.empty()); + + s.read_bytes(data, 1024); + EXPECT_TRUE(s.empty()); +} + +/** +* test the stream utility, access require +*/ +VOID TEST(KernelStreamTest, StreamRequire) +{ + SrsStream s; + char data[1024]; + + EXPECT_FALSE(s.require(1)); + EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024)); + EXPECT_TRUE(s.require(1)); + EXPECT_TRUE(s.require(1024)); + + s.read_bytes(data, 1000); + EXPECT_TRUE(s.require(1)); + + s.read_bytes(data, 24); + EXPECT_FALSE(s.require(1)); +} + +/** +* test the stream utility, skip bytes +*/ +VOID TEST(KernelStreamTest, StreamSkip) +{ + SrsStream s; + char data[1024]; + + EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024)); + EXPECT_EQ(0, s.pos()); + + s.skip(1); + EXPECT_EQ(1, s.pos()); + + s.skip(-1); + EXPECT_EQ(0 , s.pos()); +} + +/** +* test the stream utility, read 1bytes +*/ +VOID TEST(KernelStreamTest, StreamRead1Bytes) +{ + SrsStream s; + char data[1024]; + + EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024)); + + data[0] = 0x12; + data[99] = 0x13; + data[100] = 0x14; + data[101] = 0x15; + EXPECT_EQ(0x12, s.read_1bytes()); + + s.skip(-1 * s.pos()); + s.skip(100); + EXPECT_EQ(0x14, s.read_1bytes()); +} + +/** +* test the stream utility, read 2bytes +*/ +VOID TEST(KernelStreamTest, StreamRead2Bytes) +{ + SrsStream s; + char data[1024]; + + EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024)); + + data[0] = 0x01; + data[1] = 0x02; + data[2] = 0x03; + data[3] = 0x04; + data[4] = 0x05; + data[5] = 0x06; + data[6] = 0x07; + data[7] = 0x08; + data[8] = 0x09; + data[9] = 0x0a; + + EXPECT_EQ(0x0102, s.read_2bytes()); + EXPECT_EQ(0x0304, s.read_2bytes()); + + s.skip(-1 * s.pos()); + s.skip(3); + EXPECT_EQ(0x0405, s.read_2bytes()); +} + +/** +* test the stream utility, read 3bytes +*/ +VOID TEST(KernelStreamTest, StreamRead3Bytes) +{ + SrsStream s; + char data[1024]; + + EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024)); + + data[0] = 0x01; + data[1] = 0x02; + data[2] = 0x03; + data[3] = 0x04; + data[4] = 0x05; + data[5] = 0x06; + data[6] = 0x07; + data[7] = 0x08; + data[8] = 0x09; + data[9] = 0x0a; + + EXPECT_EQ(0x010203, s.read_3bytes()); + EXPECT_EQ(0x040506, s.read_3bytes()); + + s.skip(-1 * s.pos()); + s.skip(5); + EXPECT_EQ(0x060708, s.read_3bytes()); +} + +/** +* test the stream utility, read 4bytes +*/ +VOID TEST(KernelStreamTest, StreamRead4Bytes) +{ + SrsStream s; + char data[1024]; + + EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024)); + + data[0] = 0x01; + data[1] = 0x02; + data[2] = 0x03; + data[3] = 0x04; + data[4] = 0x05; + data[5] = 0x06; + data[6] = 0x07; + data[7] = 0x08; + data[8] = 0x09; + data[9] = 0x0a; + + EXPECT_EQ(0x01020304, s.read_4bytes()); + EXPECT_EQ(0x05060708, s.read_4bytes()); + + s.skip(-1 * s.pos()); + s.skip(5); + EXPECT_EQ(0x06070809, s.read_4bytes()); +} + +/** +* test the stream utility, read 8bytes +*/ +VOID TEST(KernelStreamTest, StreamRead8Bytes) +{ + SrsStream s; + char data[1024]; + + EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024)); + + data[0] = 0x01; + data[1] = 0x02; + data[2] = 0x03; + data[3] = 0x04; + data[4] = 0x05; + data[5] = 0x06; + data[6] = 0x07; + data[7] = 0x08; + data[8] = 0x09; + data[9] = 0x0a; + data[10] = 0x0b; + data[11] = 0x0c; + data[12] = 0x0d; + data[13] = 0x0e; + data[14] = 0x0f; + data[15] = 0x10; + data[16] = 0x11; + data[17] = 0x12; + data[18] = 0x13; + data[19] = 0x14; + + EXPECT_EQ(0x0102030405060708, s.read_8bytes()); + EXPECT_EQ(0x090a0b0c0d0e0f10, s.read_8bytes()); + + s.skip(-1 * s.pos()); + s.skip(5); + EXPECT_EQ(0x060708090a0b0c0d, s.read_8bytes()); +} + +/** +* test the stream utility, read string +*/ +VOID TEST(KernelStreamTest, StreamReadString) +{ + SrsStream s; + char data[] = "Hello, world!"; + + EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, sizeof(data) - 1)); + + string str = s.read_string(2); + EXPECT_STREQ("He", str.c_str()); + + str = s.read_string(2); + EXPECT_STREQ("ll", str.c_str()); + + s.skip(3); + str = s.read_string(6); + EXPECT_STREQ("world!", str.c_str()); + + EXPECT_TRUE(s.empty()); +} + +/** +* test the stream utility, read bytes +*/ +VOID TEST(KernelStreamTest, StreamReadBytes) +{ + SrsStream s; + char data[] = "Hello, world!"; + + EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, sizeof(data) - 1)); + + char bytes[64]; + s.read_bytes(bytes, 2); + bytes[2] = 0; + EXPECT_STREQ("He", bytes); + + s.read_bytes(bytes, 2); + bytes[2] = 0; + EXPECT_STREQ("ll", bytes); + + s.skip(3); + s.read_bytes(bytes, 6); + bytes[6] = 0; + EXPECT_STREQ("world!", bytes); + + EXPECT_TRUE(s.empty()); +} + +/** +* test the stream utility, write 1bytes +*/ +VOID TEST(KernelStreamTest, StreamWrite1Bytes) +{ + SrsStream s; + char data[1024]; + + EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024)); + + s.write_1bytes(0x10); + s.write_1bytes(0x11); + s.write_1bytes(0x12); + s.write_1bytes(0x13); + + s.skip(-1 * s.pos()); + EXPECT_EQ(0x10, s.read_1bytes()); + s.skip(2); + EXPECT_EQ(0x13, s.read_1bytes()); +} + +/** +* test the stream utility, write 2bytes +*/ +VOID TEST(KernelStreamTest, StreamWrite2Bytes) +{ + SrsStream s; + char data[1024]; + + EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024)); + + s.write_2bytes(0x1011); + s.write_2bytes(0x1213); + s.write_2bytes(0x1415); + s.write_2bytes(0x1617); + s.write_2bytes(0x1819); + + s.skip(-1 * s.pos()); + EXPECT_EQ(0x10, s.read_1bytes()); + s.skip(2); + EXPECT_EQ(0x13, s.read_1bytes()); + s.skip(5); + EXPECT_EQ(0x19, s.read_1bytes()); +} + +/** +* test the stream utility, write 3bytes +*/ +VOID TEST(KernelStreamTest, StreamWrite3Bytes) +{ + SrsStream s; + char data[1024]; + + EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024)); + + s.write_3bytes(0x101112); + s.write_3bytes(0x131415); + s.write_3bytes(0x161718); + s.write_3bytes(0x192021); + + s.skip(-1 * s.pos()); + EXPECT_EQ(0x10, s.read_1bytes()); + s.skip(2); + EXPECT_EQ(0x13, s.read_1bytes()); + s.skip(5); + EXPECT_EQ(0x19, s.read_1bytes()); +} + +/** +* test the stream utility, write 34bytes +*/ +VOID TEST(KernelStreamTest, StreamWrite4Bytes) +{ + SrsStream s; + char data[1024]; + + EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024)); + + s.write_4bytes(0x10111213); + s.write_4bytes(0x14151617); + s.write_4bytes(0x18192021); + + s.skip(-1 * s.pos()); + EXPECT_EQ(0x10, s.read_1bytes()); + s.skip(2); + EXPECT_EQ(0x13, s.read_1bytes()); + s.skip(5); + EXPECT_EQ(0x19, s.read_1bytes()); +} + +/** +* test the stream utility, write 8bytes +*/ +VOID TEST(KernelStreamTest, StreamWrite8Bytes) +{ + SrsStream s; + char data[1024]; + + EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024)); + + s.write_8bytes(0x1011121314151617); + s.write_8bytes(0x1819202122232425); + + s.skip(-1 * s.pos()); + EXPECT_EQ(0x10, s.read_1bytes()); + s.skip(2); + EXPECT_EQ(0x13, s.read_1bytes()); + s.skip(5); + EXPECT_EQ(0x19, s.read_1bytes()); +} + +/** +* test the stream utility, write string +*/ +VOID TEST(KernelStreamTest, StreamWriteString) +{ + SrsStream s; + char data[1024]; + + EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024)); + + char str[] = { + (char)0x10, (char)0x11, (char)0x12, (char)0x13, + (char)0x14, (char)0x15, (char)0x16, (char)0x17, + (char)0x18, (char)0x19, (char)0x20, (char)0x21 + }; + string str1; + str1.append(str, 12); + + s.write_string(str1); + + s.skip(-1 * s.pos()); + EXPECT_EQ(0x10, s.read_1bytes()); + s.skip(2); + EXPECT_EQ(0x13, s.read_1bytes()); + s.skip(5); + EXPECT_EQ(0x19, s.read_1bytes()); +} + +/** +* test the stream utility, write bytes +*/ +VOID TEST(KernelStreamTest, StreamWriteBytes) +{ + SrsStream s; + char data[1024]; + + EXPECT_TRUE(ERROR_SUCCESS == s.initialize(data, 1024)); + + char str[] = { + (char)0x10, (char)0x11, (char)0x12, (char)0x13, + (char)0x14, (char)0x15, (char)0x16, (char)0x17, + (char)0x18, (char)0x19, (char)0x20, (char)0x21 + }; + + s.write_bytes(str, 12); + + s.skip(-1 * s.pos()); + EXPECT_EQ(0x10, s.read_1bytes()); + s.skip(2); + EXPECT_EQ(0x13, s.read_1bytes()); + s.skip(5); + EXPECT_EQ(0x19, s.read_1bytes()); +} + +/** +* test the kernel utility, time +*/ +VOID TEST(KernelUtilityTest, UtilityTime) +{ + int64_t time = srs_get_system_time_ms(); + EXPECT_TRUE(time > 0); + + int64_t time1 = srs_get_system_time_ms(); + EXPECT_EQ(time, time1); + + usleep(1000); + srs_update_system_time_ms(); + time1 = srs_get_system_time_ms(); + EXPECT_TRUE(time1 > time); +} + +/** +* test the kernel utility, startup time +*/ +VOID TEST(KernelUtilityTest, UtilityStartupTime) +{ + int64_t time = srs_get_system_startup_time_ms(); + EXPECT_TRUE(time > 0); + + int64_t time1 = srs_get_system_startup_time_ms(); + EXPECT_EQ(time, time1); + + usleep(1000); + srs_update_system_time_ms(); + time1 = srs_get_system_startup_time_ms(); + EXPECT_EQ(time, time1); +} + +/** +* test the kernel utility, little endian +*/ +VOID TEST(KernelUtilityTest, UtilityLittleEndian) +{ + EXPECT_TRUE(srs_is_little_endian()); +} + +/** +* test the kernel utility, string +*/ +VOID TEST(KernelUtilityTest, UtilityString) +{ + string str = "Hello, World! Hello, SRS!"; + string str1; + + str1 = srs_string_replace(str, "xxx", ""); + EXPECT_STREQ("Hello, World! Hello, SRS!", str1.c_str()); + + str1 = srs_string_replace(str, "He", "XX"); + EXPECT_STREQ("XXllo, World! XXllo, SRS!", str1.c_str()); + + str1 = srs_string_replace(str, "o", "XX"); + EXPECT_STREQ("HellXX, WXXrld! HellXX, SRS!", str1.c_str()); + + str1 = srs_string_trim_end(str, "x"); + EXPECT_STREQ("Hello, World! Hello, SRS!", str1.c_str()); + + str1 = srs_string_trim_end(str, "He"); + EXPECT_STREQ("Hello, World! Hello, SRS!", str1.c_str()); + + str1 = srs_string_trim_end(str, "HeS!R"); + EXPECT_STREQ("Hello, World! Hello, ", str1.c_str()); + + str1 = srs_string_remove(str, "x"); + EXPECT_STREQ("Hello, World! Hello, SRS!", str1.c_str()); + + str1 = srs_string_remove(str, "o"); + EXPECT_STREQ("Hell, Wrld! Hell, SRS!", str1.c_str()); + + str1 = srs_string_remove(str, "ol"); + EXPECT_STREQ("He, Wrd! He, SRS!", str1.c_str()); + + EXPECT_FALSE(srs_string_ends_with("Hello", "x")); + EXPECT_TRUE(srs_string_ends_with("Hello", "o")); + EXPECT_TRUE(srs_string_ends_with("Hello", "lo")); +}