Blame view

trunk/src/utest/srs_utest_amf0.cpp 38.1 KB
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
/*
The MIT License (MIT)

Copyright (c) 2013-2014 winlin

Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <srs_utest_amf0.hpp>
winlin authored
25 26
#ifdef ENABLE_UTEST_AMF0
27 28 29
#include <string>
using namespace std;
30
#include <srs_core_autofree.hpp>
31 32
#include <srs_kernel_error.hpp>
#include <srs_kernel_stream.hpp>
33
34 35 36 37
/**
* main scenario to use amf0.
* user scenario: coding and decoding with amf0
*/
38
VOID TEST(ProtocolAMF0Test, ScenarioMain)
39
{
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
    // coded amf0 object
    int nb_bytes = 0;
    char* bytes = NULL;
    
    // coding data to binaries by amf0
    // for example, send connect app response to client.
    if (true) {
        // props: object
        //        fmsVer: string
        //        capabilities: number
        //        mode: number
        // info: object
        //         level: string
        //        code: string
        //        descrption: string
        //        objectEncoding: number
        //        data: array
        //                version: string
        //                srs_sig: string
        SrsAmf0Object* props = SrsAmf0Any::object();
60
        SrsAutoFree(SrsAmf0Object, props);
61 62 63 64 65
        props->set("fmsVer", SrsAmf0Any::str("FMS/3,5,3,888"));
        props->set("capabilities", SrsAmf0Any::number(253));
        props->set("mode", SrsAmf0Any::number(123));
        
        SrsAmf0Object* info = SrsAmf0Any::object();
66
        SrsAutoFree(SrsAmf0Object, info);
67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92
        info->set("level", SrsAmf0Any::str("info"));
        info->set("code", SrsAmf0Any::str("NetStream.Connnect.Success"));
        info->set("descrption", SrsAmf0Any::str("connected"));
        info->set("objectEncoding", SrsAmf0Any::number(3));
        
        SrsAmf0EcmaArray* data = SrsAmf0Any::ecma_array();
        info->set("data", data);
        data->set("version", SrsAmf0Any::str("FMS/3,5,3,888"));
        data->set("srs_sig", SrsAmf0Any::str("srs"));
        
        // buf store the serialized props/info
        nb_bytes = props->total_size() + info->total_size();
        ASSERT_GT(nb_bytes, 0);
        bytes = new char[nb_bytes];
        
        // use SrsStream to write props/info to binary buf.
        SrsStream s;
        EXPECT_EQ(ERROR_SUCCESS, s.initialize(bytes, nb_bytes));
        EXPECT_EQ(ERROR_SUCCESS, props->write(&s));
        EXPECT_EQ(ERROR_SUCCESS, info->write(&s));
        EXPECT_TRUE(s.empty());
        
        // now, user can use the buf
        EXPECT_EQ(0x03, bytes[0]);
        EXPECT_EQ(0x09, bytes[nb_bytes - 1]);
    }
93
    SrsAutoFree(char, bytes);
94 95 96 97 98 99 100 101 102 103 104 105 106 107
    
    // decoding amf0 object from bytes
    // when user know the schema
    if (true) {
        ASSERT_TRUE(NULL != bytes);
        
        // use SrsStream to assist amf0 object to read from bytes.
        SrsStream s;
        EXPECT_EQ(ERROR_SUCCESS, s.initialize(bytes, nb_bytes));
        
        // decoding
        // if user know the schema, for instance, it's an amf0 object,
        // user can use specified object to decoding.
        SrsAmf0Object* props = SrsAmf0Any::object();
108
        SrsAutoFree(SrsAmf0Object, props);
109 110 111 112
        EXPECT_EQ(ERROR_SUCCESS, props->read(&s));
        
        // user can use specified object to decoding.
        SrsAmf0Object* info = SrsAmf0Any::object();
113
        SrsAutoFree(SrsAmf0Object, info);
114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
        EXPECT_EQ(ERROR_SUCCESS, info->read(&s));
        
        // use the decoded data.
        SrsAmf0Any* prop = NULL;
        
        // if user requires specified property, use ensure of amf0 object
        EXPECT_TRUE(NULL != (prop = props->ensure_property_string("fmsVer")));
        // the property can assert to string.
        ASSERT_TRUE(prop->is_string());
        // get the prop string value.
        EXPECT_STREQ("FMS/3,5,3,888", prop->to_str().c_str());
        
        // get other type property value
        EXPECT_TRUE(NULL != (prop = info->get_property("data")));
        // we cannot assert the property is ecma array
        if (prop->is_ecma_array()) {
            SrsAmf0EcmaArray* data = prop->to_ecma_array();
            // it must be a ecma array.
            ASSERT_TRUE(NULL != data);
            
            // get property of array
            EXPECT_TRUE(NULL != (prop = data->ensure_property_string("srs_sig")));
            ASSERT_TRUE(prop->is_string());
            EXPECT_STREQ("srs", prop->to_str().c_str());
        }
        
        // confidence about the schema
        EXPECT_TRUE(NULL != (prop = info->ensure_property_string("level")));
        ASSERT_TRUE(prop->is_string());
        EXPECT_STREQ("info", prop->to_str().c_str());
    }
    
    // use any to decoding it,
    // if user donot know the schema
    if (true) {
        ASSERT_TRUE(NULL != bytes);
        
        // use SrsStream to assist amf0 object to read from bytes.
        SrsStream s;
        EXPECT_EQ(ERROR_SUCCESS, s.initialize(bytes, nb_bytes));
        
        // decoding a amf0 any, for user donot know
        SrsAmf0Any* any = NULL;
        EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &any));
158
        SrsAutoFree(SrsAmf0Any, any);
159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176
        
        // for amf0 object
        if (any->is_object()) {
            SrsAmf0Object* obj = any->to_object();
            ASSERT_TRUE(NULL != obj);
            
            // use foreach to process properties
            for (int i = 0; i < obj->count(); ++i) {
                string name = obj->key_at(i);
                SrsAmf0Any* value = obj->value_at(i);
                
                // use the property name
                EXPECT_TRUE("" != name);
                // use the property value
                EXPECT_TRUE(NULL != value);
            }
        }
    }
177 178
}
179 180 181
/**
* to calc the size of amf0 instances.
*/
182
VOID TEST(ProtocolAMF0Test, ApiSize) 
183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
{
    // size of elem
    EXPECT_EQ(2+6, SrsAmf0Size::utf8("winlin"));
    EXPECT_EQ(2+0, SrsAmf0Size::utf8(""));
    
    EXPECT_EQ(1+2+6, SrsAmf0Size::str("winlin"));
    EXPECT_EQ(1+2+0, SrsAmf0Size::str(""));
    
    EXPECT_EQ(1+8, SrsAmf0Size::number());
    
    EXPECT_EQ(1, SrsAmf0Size::null());
    
    EXPECT_EQ(1, SrsAmf0Size::undefined());
    
    EXPECT_EQ(1+1, SrsAmf0Size::boolean());
    
    // object: empty
    if (true) {
        int size = 1+3;
202
        SrsAmf0Object* o = SrsAmf0Any::object();
203
        SrsAutoFree(SrsAmf0Object, o);
204
        
205
        EXPECT_EQ(size, SrsAmf0Size::object(o));
206 207 208 209
    }
    // object: elem
    if (true) {
        int size = 1+3;
210
        SrsAmf0Object* o = SrsAmf0Any::object();
211
        SrsAutoFree(SrsAmf0Object, o);
212 213
        
        size += SrsAmf0Size::utf8("name")+SrsAmf0Size::str("winlin");
214
        o->set("name", SrsAmf0Any::str("winlin"));
215
        
216
        EXPECT_EQ(size, SrsAmf0Size::object(o));
217 218 219
    }
    if (true) {
        int size = 1+3;
220
        SrsAmf0Object* o = SrsAmf0Any::object();
221
        SrsAutoFree(SrsAmf0Object, o);
222 223
        
        size += SrsAmf0Size::utf8("age")+SrsAmf0Size::number();
224
        o->set("age", SrsAmf0Any::number(9));
225
        
226
        EXPECT_EQ(size, SrsAmf0Size::object(o));
227 228 229
    }
    if (true) {
        int size = 1+3;
230
        SrsAmf0Object* o = SrsAmf0Any::object();
231
        SrsAutoFree(SrsAmf0Object, o);
232 233
        
        size += SrsAmf0Size::utf8("email")+SrsAmf0Size::null();
234
        o->set("email", SrsAmf0Any::null());
235
        
236
        EXPECT_EQ(size, SrsAmf0Size::object(o));
237 238 239
    }
    if (true) {
        int size = 1+3;
240
        SrsAmf0Object* o = SrsAmf0Any::object();
241
        SrsAutoFree(SrsAmf0Object, o);
242 243
        
        size += SrsAmf0Size::utf8("email")+SrsAmf0Size::undefined();
244
        o->set("email", SrsAmf0Any::undefined());
245
        
246
        EXPECT_EQ(size, SrsAmf0Size::object(o));
247 248 249
    }
    if (true) {
        int size = 1+3;
250
        SrsAmf0Object* o = SrsAmf0Any::object();
251
        SrsAutoFree(SrsAmf0Object, o);
252 253
        
        size += SrsAmf0Size::utf8("sex")+SrsAmf0Size::boolean();
254
        o->set("sex", SrsAmf0Any::boolean(true));
255
        
256
        EXPECT_EQ(size, SrsAmf0Size::object(o));
257 258 259 260 261
    }
    
    // array: empty
    if (true) {
        int size = 1+4+3;
262
        SrsAmf0EcmaArray* o = SrsAmf0Any::ecma_array();
263
        SrsAutoFree(SrsAmf0EcmaArray, o);
264
        
265
        EXPECT_EQ(size, SrsAmf0Size::ecma_array(o));
266 267 268 269
    }
    // array: elem
    if (true) {
        int size = 1+4+3;
270
        SrsAmf0EcmaArray* o = SrsAmf0Any::ecma_array();
271
        SrsAutoFree(SrsAmf0EcmaArray, o);
272 273
        
        size += SrsAmf0Size::utf8("name")+SrsAmf0Size::str("winlin");
274
        o->set("name", SrsAmf0Any::str("winlin"));
275
        
276
        EXPECT_EQ(size, SrsAmf0Size::ecma_array(o));
277 278 279
    }
    if (true) {
        int size = 1+4+3;
280
        SrsAmf0EcmaArray* o = SrsAmf0Any::ecma_array();
281
        SrsAutoFree(SrsAmf0EcmaArray, o);
282 283
        
        size += SrsAmf0Size::utf8("age")+SrsAmf0Size::number();
284
        o->set("age", SrsAmf0Any::number(9));
285
        
286
        EXPECT_EQ(size, SrsAmf0Size::ecma_array(o));
287 288 289
    }
    if (true) {
        int size = 1+4+3;
290
        SrsAmf0EcmaArray* o = SrsAmf0Any::ecma_array();
291
        SrsAutoFree(SrsAmf0EcmaArray, o);
292 293
        
        size += SrsAmf0Size::utf8("email")+SrsAmf0Size::null();
294
        o->set("email", SrsAmf0Any::null());
295
        
296
        EXPECT_EQ(size, SrsAmf0Size::ecma_array(o));
297 298 299
    }
    if (true) {
        int size = 1+4+3;
300
        SrsAmf0EcmaArray* o = SrsAmf0Any::ecma_array();
301
        SrsAutoFree(SrsAmf0EcmaArray, o);
302 303
        
        size += SrsAmf0Size::utf8("email")+SrsAmf0Size::undefined();
304
        o->set("email", SrsAmf0Any::undefined());
305
        
306
        EXPECT_EQ(size, SrsAmf0Size::ecma_array(o));
307 308 309
    }
    if (true) {
        int size = 1+4+3;
310
        SrsAmf0EcmaArray* o = SrsAmf0Any::ecma_array();
311
        SrsAutoFree(SrsAmf0EcmaArray, o);
312 313
        
        size += SrsAmf0Size::utf8("sex")+SrsAmf0Size::boolean();
314
        o->set("sex", SrsAmf0Any::boolean(true));
315
        
316
        EXPECT_EQ(size, SrsAmf0Size::ecma_array(o));
317 318 319 320 321
    }
    
    // object: array
    if (true) {
        int size = 1+3;
322
        SrsAmf0Object* o = SrsAmf0Any::object();
323
        SrsAutoFree(SrsAmf0Object, o);
324 325
        
        size += SrsAmf0Size::utf8("name")+SrsAmf0Size::str("winlin");
326
        o->set("name", SrsAmf0Any::str("winlin"));
327
        
328
        SrsAmf0EcmaArray* args = SrsAmf0Any::ecma_array();
329
        args->set("p0", SrsAmf0Any::str("function"));
330
        size += SrsAmf0Size::utf8("args")+SrsAmf0Size::ecma_array(args);
331
        o->set("args", args);
332
        
333
        EXPECT_EQ(size, SrsAmf0Size::object(o));
334 335 336
    }
    if (true) {
        int size = 1+3;
337
        SrsAmf0Object* o = SrsAmf0Any::object();
338
        SrsAutoFree(SrsAmf0Object, o);
339 340
        
        size += SrsAmf0Size::utf8("name")+SrsAmf0Size::str("winlin");
341
        o->set("name", SrsAmf0Any::str("winlin"));
342
        
343
        SrsAmf0EcmaArray* args = SrsAmf0Any::ecma_array();
344
        args->set("p0", SrsAmf0Any::str("function"));
345
        size += SrsAmf0Size::utf8("args")+SrsAmf0Size::ecma_array(args);
346
        o->set("args", args);
347
        
348
        SrsAmf0EcmaArray* params = SrsAmf0Any::ecma_array();
349
        params->set("p1", SrsAmf0Any::number(10));
350
        size += SrsAmf0Size::utf8("params")+SrsAmf0Size::ecma_array(params);
351
        o->set("params", params);
352
        
353
        EXPECT_EQ(size, SrsAmf0Size::object(o));
354 355 356 357 358
    }
    
    // array: object
    if (true) {
        int size = 1+4+3;
359
        SrsAmf0EcmaArray* o = SrsAmf0Any::ecma_array();
360
        SrsAutoFree(SrsAmf0EcmaArray, o);
361 362
        
        size += SrsAmf0Size::utf8("name")+SrsAmf0Size::str("winlin");
363
        o->set("name", SrsAmf0Any::str("winlin"));
364
        
365
        SrsAmf0Object* args = SrsAmf0Any::object();
366
        args->set("p0", SrsAmf0Any::str("function"));
367
        size += SrsAmf0Size::utf8("args")+SrsAmf0Size::object(args);
368
        o->set("args", args);
369
        
370
        EXPECT_EQ(size, SrsAmf0Size::ecma_array(o));
371 372 373
    }
    if (true) {
        int size = 1+4+3;
374
        SrsAmf0EcmaArray* o = SrsAmf0Any::ecma_array();
375
        SrsAutoFree(SrsAmf0EcmaArray, o);
376 377
        
        size += SrsAmf0Size::utf8("name")+SrsAmf0Size::str("winlin");
378
        o->set("name", SrsAmf0Any::str("winlin"));
379
        
380
        SrsAmf0Object* args = SrsAmf0Any::object();
381
        args->set("p0", SrsAmf0Any::str("function"));
382
        size += SrsAmf0Size::utf8("args")+SrsAmf0Size::object(args);
383
        o->set("args", args);
384
        
385
        SrsAmf0Object* params = SrsAmf0Any::object();
386
        params->set("p1", SrsAmf0Any::number(10));
387
        size += SrsAmf0Size::utf8("params")+SrsAmf0Size::object(params);
388
        o->set("params", params);
389
        
390
        EXPECT_EQ(size, SrsAmf0Size::ecma_array(o));
391 392 393 394 395
    }
    
    // object: object
    if (true) {
        int size = 1+3;
396
        SrsAmf0Object* o = SrsAmf0Any::object();
397
        SrsAutoFree(SrsAmf0Object, o);
398 399
        
        size += SrsAmf0Size::utf8("name")+SrsAmf0Size::str("winlin");
400
        o->set("name", SrsAmf0Any::str("winlin"));
401
        
402
        SrsAmf0Object* args = SrsAmf0Any::object();
403
        args->set("p0", SrsAmf0Any::str("function"));
404
        size += SrsAmf0Size::utf8("args")+SrsAmf0Size::object(args);
405
        o->set("args", args);
406
        
407
        SrsAmf0Object* params = SrsAmf0Any::object();
408
        params->set("p1", SrsAmf0Any::number(10));
409
        size += SrsAmf0Size::utf8("params")+SrsAmf0Size::object(params);
410
        o->set("params", params);
411
        
412
        EXPECT_EQ(size, SrsAmf0Size::object(o));
413 414 415 416 417
    }
    
    // array: array
    if (true) {
        int size = 1+4+3;
418
        SrsAmf0EcmaArray* o = SrsAmf0Any::ecma_array();
419
        SrsAutoFree(SrsAmf0EcmaArray, o);
420 421
        
        size += SrsAmf0Size::utf8("name")+SrsAmf0Size::str("winlin");
422
        o->set("name", SrsAmf0Any::str("winlin"));
423
        
424
        SrsAmf0EcmaArray* args = SrsAmf0Any::ecma_array();
425
        args->set("p0", SrsAmf0Any::str("function"));
426
        size += SrsAmf0Size::utf8("args")+SrsAmf0Size::ecma_array(args);
427
        o->set("args", args);
428
        
429
        SrsAmf0EcmaArray* params = SrsAmf0Any::ecma_array();
430
        params->set("p1", SrsAmf0Any::number(10));
431
        size += SrsAmf0Size::utf8("params")+SrsAmf0Size::ecma_array(params);
432
        o->set("params", params);
433
        
434
        EXPECT_EQ(size, SrsAmf0Size::ecma_array(o)); 
435 436
    }
}
437
438 439 440
/**
* about the AMF0 any.
*/
441
VOID TEST(ProtocolAMF0Test, ApiAnyElem) 
442
{
443 444 445 446 447
    SrsAmf0Any* o = NULL;
    
    // string
    if (true) {
        o = SrsAmf0Any::str();
448
        SrsAutoFree(SrsAmf0Any, o);
449 450 451 452 453 454
        ASSERT_TRUE(NULL != o);
        EXPECT_TRUE(o->is_string());
        EXPECT_STREQ("", o->to_str().c_str());
    }
    if (true) {
        o = SrsAmf0Any::str("winlin");
455
        SrsAutoFree(SrsAmf0Any, o);
456 457 458 459 460 461 462 463
        ASSERT_TRUE(NULL != o);
        EXPECT_TRUE(o->is_string());
        EXPECT_STREQ("winlin", o->to_str().c_str());
    }
    
    // bool
    if (true) {
        o = SrsAmf0Any::boolean();
464
        SrsAutoFree(SrsAmf0Any, o);
465 466 467 468 469 470
        ASSERT_TRUE(NULL != o);
        EXPECT_TRUE(o->is_boolean());
        EXPECT_FALSE(o->to_boolean());
    }
    if (true) {
        o = SrsAmf0Any::boolean(false);
471
        SrsAutoFree(SrsAmf0Any, o);
472 473 474 475 476 477
        ASSERT_TRUE(NULL != o);
        EXPECT_TRUE(o->is_boolean());
        EXPECT_FALSE(o->to_boolean());
    }
    if (true) {
        o = SrsAmf0Any::boolean(true);
478
        SrsAutoFree(SrsAmf0Any, o);
479 480 481 482 483 484 485 486
        ASSERT_TRUE(NULL != o);
        EXPECT_TRUE(o->is_boolean());
        EXPECT_TRUE(o->to_boolean());
    }
    
    // number
    if (true) {
        o = SrsAmf0Any::number();
487
        SrsAutoFree(SrsAmf0Any, o);
488 489 490 491 492 493
        ASSERT_TRUE(NULL != o);
        EXPECT_TRUE(o->is_number());
        EXPECT_DOUBLE_EQ(0, o->to_number());
    }
    if (true) {
        o = SrsAmf0Any::number(100);
494
        SrsAutoFree(SrsAmf0Any, o);
495 496 497 498 499 500
        ASSERT_TRUE(NULL != o);
        EXPECT_TRUE(o->is_number());
        EXPECT_DOUBLE_EQ(100, o->to_number());
    }
    if (true) {
        o = SrsAmf0Any::number(-100);
501
        SrsAutoFree(SrsAmf0Any, o);
502 503 504 505
        ASSERT_TRUE(NULL != o);
        EXPECT_TRUE(o->is_number());
        EXPECT_DOUBLE_EQ(-100, o->to_number());
    }
506
507 508 509
    // null
    if (true) {
        o = SrsAmf0Any::null();
510
        SrsAutoFree(SrsAmf0Any, o);
511 512 513
        ASSERT_TRUE(NULL != o);
        EXPECT_TRUE(o->is_null());
    }
514
515 516 517
    // undefined
    if (true) {
        o = SrsAmf0Any::undefined();
518
        SrsAutoFree(SrsAmf0Any, o);
519 520 521
        ASSERT_TRUE(NULL != o);
        EXPECT_TRUE(o->is_undefined());
    }
522
}
523
524 525 526
/**
* about the stream to serialize/deserialize AMF0 instance.
*/
527
VOID TEST(ProtocolAMF0Test, ApiAnyIO) 
528
{
529 530 531 532 533 534 535 536 537
    SrsStream s;
    SrsAmf0Any* o = NULL;
    
    char buf[1024];
    memset(buf, 0, sizeof(buf));
    EXPECT_EQ(ERROR_SUCCESS, s.initialize(buf, sizeof(buf)));
    
    // object eof
    if (true) {
538 539
        s.skip(-1 * s.pos());
        (s.data() + s.pos())[2] = 0x09;
540 541
        
        o = SrsAmf0Any::object_eof();
542
        SrsAutoFree(SrsAmf0Any, o);
543 544 545 546 547
        
        EXPECT_EQ(ERROR_SUCCESS, o->read(&s));
        EXPECT_EQ(o->total_size(), s.pos());
        EXPECT_EQ(3, s.pos());
        
548 549
        s.skip(-1 * s.pos());
        (s.data() + s.pos())[0] = 0x01;
550 551 552
        EXPECT_NE(ERROR_SUCCESS, o->read(&s));
    }
    if (true) {
553
        s.skip(-1 * s.pos());
554 555
        
        o = SrsAmf0Any::object_eof();
556
        SrsAutoFree(SrsAmf0Any, o);
557 558 559 560 561 562 563 564 565 566 567
        
        EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
        EXPECT_EQ(o->total_size(), s.pos());
        EXPECT_EQ(3, s.pos());
        
        s.skip(-3);
        EXPECT_EQ(0x09, s.read_3bytes());
    }
    
    // string
    if (true) {
568
        s.skip(-1 * s.pos());
569 570
        
        o = SrsAmf0Any::str("winlin");
571
        SrsAutoFree(SrsAmf0Any, o);
572 573 574 575
        
        EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
        EXPECT_EQ(o->total_size(), s.pos());
        
576
        s.skip(-1 * s.pos());
577 578
        EXPECT_EQ(2, s.read_1bytes());
        EXPECT_EQ(6, s.read_2bytes());
579 580
        EXPECT_EQ('w', (s.data() + s.pos())[0]);
        EXPECT_EQ('n', (s.data() + s.pos())[5]);
581
        
582 583
        s.skip(-1 * s.pos());
        (s.data() + s.pos())[3] = 'x';
584 585 586 587 588 589 590
        EXPECT_EQ(ERROR_SUCCESS, o->read(&s));
        EXPECT_EQ(o->total_size(), s.pos());
        EXPECT_STREQ("xinlin", o->to_str().c_str());
    }
    
    // number
    if (true) {
591
        s.skip(-1 * s.pos());
592 593
        
        o = SrsAmf0Any::number(10);
594
        SrsAutoFree(SrsAmf0Any, o);
595 596 597
        
        EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
        EXPECT_EQ(o->total_size(), s.pos());
598
599
        s.skip(-1 * s.pos());
600 601
        EXPECT_EQ(0, s.read_1bytes());
        
602
        s.skip(-1 * s.pos());
603 604 605 606 607 608 609
        EXPECT_EQ(ERROR_SUCCESS, o->read(&s));
        EXPECT_EQ(o->total_size(), s.pos());
        EXPECT_DOUBLE_EQ(10, o->to_number());
    }
    
    // boolean
    if (true) {
610
        s.skip(-1 * s.pos());
611 612
        
        o = SrsAmf0Any::boolean(true);
613
        SrsAutoFree(SrsAmf0Any, o);
614 615 616
        
        EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
        EXPECT_EQ(o->total_size(), s.pos());
617
618
        s.skip(-1 * s.pos());
619 620
        EXPECT_EQ(1, s.read_1bytes());
        
621
        s.skip(-1 * s.pos());
622 623 624 625 626
        EXPECT_EQ(ERROR_SUCCESS, o->read(&s));
        EXPECT_EQ(o->total_size(), s.pos());
        EXPECT_TRUE(o->to_boolean());
    }
    if (true) {
627
        s.skip(-1 * s.pos());
628 629
        
        o = SrsAmf0Any::boolean(false);
630
        SrsAutoFree(SrsAmf0Any, o);
631 632 633
        
        EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
        EXPECT_EQ(o->total_size(), s.pos());
634
635
        s.skip(-1 * s.pos());
636 637
        EXPECT_EQ(1, s.read_1bytes());
        
638
        s.skip(-1 * s.pos());
639 640 641 642 643 644 645
        EXPECT_EQ(ERROR_SUCCESS, o->read(&s));
        EXPECT_EQ(o->total_size(), s.pos());
        EXPECT_FALSE(o->to_boolean());
    }
    
    // null
    if (true) {
646
        s.skip(-1 * s.pos());
647 648
        
        o = SrsAmf0Any::null();
649
        SrsAutoFree(SrsAmf0Any, o);
650 651 652
        
        EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
        EXPECT_EQ(o->total_size(), s.pos());
653
654
        s.skip(-1 * s.pos());
655 656
        EXPECT_EQ(5, s.read_1bytes());
        
657
        s.skip(-1 * s.pos());
658 659 660 661 662 663 664
        EXPECT_EQ(ERROR_SUCCESS, o->read(&s));
        EXPECT_EQ(o->total_size(), s.pos());
        EXPECT_TRUE(o->is_null());
    }
    
    // undefined
    if (true) {
665
        s.skip(-1 * s.pos());
666 667
        
        o = SrsAmf0Any::undefined();
668
        SrsAutoFree(SrsAmf0Any, o);
669 670 671
        
        EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
        EXPECT_EQ(o->total_size(), s.pos());
672
673
        s.skip(-1 * s.pos());
674 675
        EXPECT_EQ(6, s.read_1bytes());
        
676
        s.skip(-1 * s.pos());
677 678 679 680
        EXPECT_EQ(ERROR_SUCCESS, o->read(&s));
        EXPECT_EQ(o->total_size(), s.pos());
        EXPECT_TRUE(o->is_undefined());
    }
681
682 683
    // any: string
    if (true) {
684
        s.skip(-1 * s.pos());
685 686
        
        o = SrsAmf0Any::str("winlin");
687
        SrsAutoFree(SrsAmf0Any, o);
688 689 690
        
        EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
        EXPECT_EQ(o->total_size(), s.pos());
691
692
        s.skip(-1 * s.pos());
693 694 695 696
        
        SrsAmf0Any* po = NULL;
        EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po));
        ASSERT_TRUE(NULL != po);
697
        SrsAutoFree(SrsAmf0Any, po);
698 699 700
        ASSERT_TRUE(po->is_string());
        EXPECT_STREQ("winlin", po->to_str().c_str());
    }
701
702 703
    // any: number
    if (true) {
704
        s.skip(-1 * s.pos());
705 706
        
        o = SrsAmf0Any::number(10);
707
        SrsAutoFree(SrsAmf0Any, o);
708 709 710
        
        EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
        EXPECT_EQ(o->total_size(), s.pos());
711
712
        s.skip(-1 * s.pos());
713 714 715 716
        
        SrsAmf0Any* po = NULL;
        EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po));
        ASSERT_TRUE(NULL != po);
717
        SrsAutoFree(SrsAmf0Any, po);
718 719 720
        ASSERT_TRUE(po->is_number());
        EXPECT_DOUBLE_EQ(10, po->to_number());
    }
721
722 723
    // any: boolean
    if (true) {
724
        s.skip(-1 * s.pos());
725 726
        
        o = SrsAmf0Any::boolean(true);
727
        SrsAutoFree(SrsAmf0Any, o);
728 729 730
        
        EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
        EXPECT_EQ(o->total_size(), s.pos());
731
732
        s.skip(-1 * s.pos());
733 734 735 736
        
        SrsAmf0Any* po = NULL;
        EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po));
        ASSERT_TRUE(NULL != po);
737
        SrsAutoFree(SrsAmf0Any, po);
738 739 740
        ASSERT_TRUE(po->is_boolean());
        EXPECT_TRUE(po->to_boolean());
    }
741
742 743
    // any: null
    if (true) {
744
        s.skip(-1 * s.pos());
745 746
        
        o = SrsAmf0Any::null();
747
        SrsAutoFree(SrsAmf0Any, o);
748 749 750
        
        EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
        EXPECT_EQ(o->total_size(), s.pos());
751
752
        s.skip(-1 * s.pos());
753 754 755 756
        
        SrsAmf0Any* po = NULL;
        EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po));
        ASSERT_TRUE(NULL != po);
757
        SrsAutoFree(SrsAmf0Any, po);
758 759
        ASSERT_TRUE(po->is_null());
    }
760
761 762
    // any: undefined
    if (true) {
763
        s.skip(-1 * s.pos());
764 765
        
        o = SrsAmf0Any::undefined();
766
        SrsAutoFree(SrsAmf0Any, o);
767 768 769
        
        EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
        EXPECT_EQ(o->total_size(), s.pos());
770
771
        s.skip(-1 * s.pos());
772 773 774 775
        
        SrsAmf0Any* po = NULL;
        EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po));
        ASSERT_TRUE(NULL != po);
776
        SrsAutoFree(SrsAmf0Any, po);
777 778 779 780 781
        ASSERT_TRUE(po->is_undefined());
    }
    
    // mixed any
    if (true) {
782
        s.skip(-1 * s.pos());
783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803
        
        o = SrsAmf0Any::str("winlin");
        EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
        srs_freep(o);
        
        o = SrsAmf0Any::number(10);
        EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
        srs_freep(o);
        
        o = SrsAmf0Any::boolean(true);
        EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
        srs_freep(o);
        
        o = SrsAmf0Any::null();
        EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
        srs_freep(o);
        
        o = SrsAmf0Any::undefined();
        EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
        srs_freep(o);
        
804
        s.skip(-1 * s.pos());
805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834
        SrsAmf0Any* po = NULL;
        
        EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po));
        ASSERT_TRUE(NULL != po);
        ASSERT_TRUE(po->is_string());
        EXPECT_STREQ("winlin", po->to_str().c_str());
        srs_freep(po);
        
        EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po));
        ASSERT_TRUE(NULL != po);
        ASSERT_TRUE(po->is_number());
        EXPECT_DOUBLE_EQ(10, po->to_number());
        srs_freep(po);
        
        EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po));
        ASSERT_TRUE(NULL != po);
        ASSERT_TRUE(po->is_boolean());
        EXPECT_TRUE(po->to_boolean());
        srs_freep(po);
        
        EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po));
        ASSERT_TRUE(NULL != po);
        ASSERT_TRUE(po->is_null());
        srs_freep(po);
        
        EXPECT_EQ(ERROR_SUCCESS, srs_amf0_read_any(&s, &po));
        ASSERT_TRUE(NULL != po);
        ASSERT_TRUE(po->is_undefined());
        srs_freep(po);
    }
835
}
836
837 838 839 840
/**
* to get the type identity
*/
VOID TEST(ProtocolAMF0Test, ApiAnyTypeAssert) 
841
{
842 843 844 845 846 847 848 849 850
    SrsStream s;
    SrsAmf0Any* o = NULL;
    
    char buf[1024];
    memset(buf, 0, sizeof(buf));
    EXPECT_EQ(ERROR_SUCCESS, s.initialize(buf, sizeof(buf)));
    
    // read any
    if (true) {
851 852
        s.skip(-1 * s.pos());
        (s.data() + s.pos())[0] = 0x12;
853 854 855 856 857 858 859 860
        EXPECT_NE(ERROR_SUCCESS, srs_amf0_read_any(&s, &o));
        EXPECT_TRUE(NULL == o);
        srs_freep(o);
    }
    
    // any convert
    if (true) {
        o = SrsAmf0Any::str();
861
        SrsAutoFree(SrsAmf0Any, o);
862 863 864 865
        EXPECT_TRUE(o->is_string());
    }
    if (true) {
        o = SrsAmf0Any::number();
866
        SrsAutoFree(SrsAmf0Any, o);
867 868 869 870
        EXPECT_TRUE(o->is_number());
    }
    if (true) {
        o = SrsAmf0Any::boolean();
871
        SrsAutoFree(SrsAmf0Any, o);
872 873 874 875
        EXPECT_TRUE(o->is_boolean());
    }
    if (true) {
        o = SrsAmf0Any::null();
876
        SrsAutoFree(SrsAmf0Any, o);
877 878 879 880
        EXPECT_TRUE(o->is_null());
    }
    if (true) {
        o = SrsAmf0Any::undefined();
881
        SrsAutoFree(SrsAmf0Any, o);
882 883 884 885
        EXPECT_TRUE(o->is_undefined());
    }
    if (true) {
        o = SrsAmf0Any::object();
886
        SrsAutoFree(SrsAmf0Any, o);
887 888 889 890
        EXPECT_TRUE(o->is_object());
    }
    if (true) {
        o = SrsAmf0Any::ecma_array();
891
        SrsAutoFree(SrsAmf0Any, o);
892 893
        EXPECT_TRUE(o->is_ecma_array());
    }
894 895 896 897 898
    if (true) {
        o = SrsAmf0Any::strict_array();
        SrsAutoFree(SrsAmf0Any, o);
        EXPECT_TRUE(o->is_strict_array());
    }
899 900 901 902
    
    // empty object
    if (true) {
        o = SrsAmf0Any::object();
903
        SrsAutoFree(SrsAmf0Any, o);
904
        s.skip(-1 * s.pos());
905 906 907 908 909 910 911
        EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
        EXPECT_EQ(1+3, s.pos());
    }
    
    // empty ecma array
    if (true) {
        o = SrsAmf0Any::ecma_array();
912
        SrsAutoFree(SrsAmf0Any, o);
913
        s.skip(-1 * s.pos());
914 915 916
        EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
        EXPECT_EQ(1+4+3, s.pos());
    }
917 918 919 920 921
    
    // strict array
    if (true) {
        o = SrsAmf0Any::strict_array();
        SrsAutoFree(SrsAmf0Any, o);
922
        s.skip(-1 * s.pos());
923 924 925
        EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
        EXPECT_EQ(1+4, s.pos());
    }
926
}
927
928 929 930
/**
* object property get/set
*/
931
VOID TEST(ProtocolAMF0Test, ApiObjectProps) 
932
{
933 934 935 936 937
    SrsAmf0Object* o = NULL;
    
    // get/set property
    if (true) {
        o = SrsAmf0Any::object();
938
        SrsAutoFree(SrsAmf0Object, o);
939 940 941 942 943 944 945 946 947 948 949 950 951 952 953
        
        EXPECT_TRUE(NULL == o->get_property("name"));
        
        o->set("name", SrsAmf0Any::str("winlin"));
        EXPECT_TRUE(NULL != o->get_property("name"));
        
        EXPECT_TRUE(NULL == o->get_property("age"));
        
        o->set("age", SrsAmf0Any::number(100));
        EXPECT_TRUE(NULL != o->get_property("age"));
    }
    
    // index property
    if (true) {
        o = SrsAmf0Any::object();
954
        SrsAutoFree(SrsAmf0Object, o);
955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973
        
        o->set("name", SrsAmf0Any::str("winlin"));
        EXPECT_STREQ("name", o->key_at(0).c_str());
        ASSERT_TRUE(o->value_at(0)->is_string());
        EXPECT_STREQ("winlin", o->value_at(0)->to_str().c_str());
        
        o->set("age", SrsAmf0Any::number(100));
        EXPECT_STREQ("name", o->key_at(0).c_str());
        ASSERT_TRUE(o->value_at(0)->is_string());
        EXPECT_STREQ("winlin", o->value_at(0)->to_str().c_str());
        
        EXPECT_STREQ("age", o->key_at(1).c_str());
        ASSERT_TRUE(o->value_at(1)->is_number());
        EXPECT_DOUBLE_EQ(100, o->value_at(1)->to_number());
    }
    
    // ensure property
    if (true) {
        o = SrsAmf0Any::object();
974
        SrsAutoFree(SrsAmf0Object, o);
975 976 977 978 979 980 981 982 983 984 985 986 987 988 989
        
        EXPECT_TRUE(NULL == o->ensure_property_string("name"));
        EXPECT_TRUE(NULL == o->ensure_property_number("age"));
        
        o->set("name", SrsAmf0Any::str("winlin"));
        EXPECT_TRUE(NULL != o->ensure_property_string("name"));
        EXPECT_TRUE(NULL == o->ensure_property_number("name"));
        EXPECT_TRUE(NULL == o->ensure_property_number("age"));
        
        o->set("age", SrsAmf0Any::number(100));
        EXPECT_TRUE(NULL != o->ensure_property_string("name"));
        EXPECT_TRUE(NULL == o->ensure_property_number("name"));
        EXPECT_TRUE(NULL != o->ensure_property_number("age"));
        EXPECT_TRUE(NULL == o->ensure_property_string("age"));
    }
990
991 992 993
    // count
    if (true) {
        o = SrsAmf0Any::object();
994
        SrsAutoFree(SrsAmf0Object, o);
995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006
        
        EXPECT_EQ(0, o->count());
        
        o->set("name", SrsAmf0Any::str("winlin"));
        EXPECT_EQ(1, o->count());
        
        o->set("name", SrsAmf0Any::str("winlin"));
        EXPECT_EQ(1, o->count());
        
        o->set("age", SrsAmf0Any::number(100));
        EXPECT_EQ(2, o->count());
    }
1007 1008
}
1009 1010 1011
/**
* ecma array properties.
*/
1012
VOID TEST(ProtocolAMF0Test, ApiEcmaArrayProps) 
1013
{
1014 1015 1016 1017 1018
    SrsAmf0EcmaArray* o = NULL;
    
    // get/set property
    if (true) {
        o = SrsAmf0Any::ecma_array();
1019
        SrsAutoFree(SrsAmf0EcmaArray, o);
1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034
        
        EXPECT_TRUE(NULL == o->get_property("name"));
        
        o->set("name", SrsAmf0Any::str("winlin"));
        EXPECT_TRUE(NULL != o->get_property("name"));
        
        EXPECT_TRUE(NULL == o->get_property("age"));
        
        o->set("age", SrsAmf0Any::number(100));
        EXPECT_TRUE(NULL != o->get_property("age"));
    }
    
    // index property
    if (true) {
        o = SrsAmf0Any::ecma_array();
1035
        SrsAutoFree(SrsAmf0EcmaArray, o);
1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054
        
        o->set("name", SrsAmf0Any::str("winlin"));
        EXPECT_STREQ("name", o->key_at(0).c_str());
        ASSERT_TRUE(o->value_at(0)->is_string());
        EXPECT_STREQ("winlin", o->value_at(0)->to_str().c_str());
        
        o->set("age", SrsAmf0Any::number(100));
        EXPECT_STREQ("name", o->key_at(0).c_str());
        ASSERT_TRUE(o->value_at(0)->is_string());
        EXPECT_STREQ("winlin", o->value_at(0)->to_str().c_str());
        
        EXPECT_STREQ("age", o->key_at(1).c_str());
        ASSERT_TRUE(o->value_at(1)->is_number());
        EXPECT_DOUBLE_EQ(100, o->value_at(1)->to_number());
    }
    
    // ensure property
    if (true) {
        o = SrsAmf0Any::ecma_array();
1055
        SrsAutoFree(SrsAmf0EcmaArray, o);
1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070
        
        EXPECT_TRUE(NULL == o->ensure_property_string("name"));
        EXPECT_TRUE(NULL == o->ensure_property_number("age"));
        
        o->set("name", SrsAmf0Any::str("winlin"));
        EXPECT_TRUE(NULL != o->ensure_property_string("name"));
        EXPECT_TRUE(NULL == o->ensure_property_number("name"));
        EXPECT_TRUE(NULL == o->ensure_property_number("age"));
        
        o->set("age", SrsAmf0Any::number(100));
        EXPECT_TRUE(NULL != o->ensure_property_string("name"));
        EXPECT_TRUE(NULL == o->ensure_property_number("name"));
        EXPECT_TRUE(NULL != o->ensure_property_number("age"));
        EXPECT_TRUE(NULL == o->ensure_property_string("age"));
    }
1071
1072 1073 1074
    // count
    if (true) {
        o = SrsAmf0Any::ecma_array();
1075
        SrsAutoFree(SrsAmf0EcmaArray, o);
1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087
        
        EXPECT_EQ(0, o->count());
        
        o->set("name", SrsAmf0Any::str("winlin"));
        EXPECT_EQ(1, o->count());
        
        o->set("name", SrsAmf0Any::str("winlin"));
        EXPECT_EQ(1, o->count());
        
        o->set("age", SrsAmf0Any::number(100));
        EXPECT_EQ(2, o->count());
    }
1088
}
1089
1090 1091 1092
/**
* strict array.
*/
1093
VOID TEST(ProtocolAMF0Test, ApiStrictArray)
1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139
{
    SrsStream s;
    
    char buf[1024];
    memset(buf, 0, sizeof(buf));
    EXPECT_EQ(ERROR_SUCCESS, s.initialize(buf, sizeof(buf)));
    
    SrsAmf0StrictArray* o = NULL;
    
    // append property
    if (true) {
        o = SrsAmf0Any::strict_array();
        SrsAutoFree(SrsAmf0StrictArray, o);
        
        o->append(SrsAmf0Any::number(100));
        EXPECT_DOUBLE_EQ(100, o->at(0)->to_number());
        
        o->append(SrsAmf0Any::number(101));
        EXPECT_DOUBLE_EQ(101, o->at(1)->to_number());
        
        o->append(SrsAmf0Any::str("winlin"));
        EXPECT_STREQ("winlin", o->at(2)->to_str().c_str());
    }
    
    // count
    if (true) {
        o = SrsAmf0Any::strict_array();
        SrsAutoFree(SrsAmf0StrictArray, o);
        
        EXPECT_EQ(0, o->count());
        
        o->append(SrsAmf0Any::boolean());
        EXPECT_EQ(1, o->count());
        
        o->append(SrsAmf0Any::boolean());
        EXPECT_EQ(2, o->count());

        o->clear();
        EXPECT_EQ(0, o->count());
    }
    
    // io
    if (true) {
        o = SrsAmf0Any::strict_array();
        SrsAutoFree(SrsAmf0StrictArray, o);
        
1140
        s.skip(-1 * s.pos());
1141 1142 1143
        EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
        EXPECT_EQ(5, s.pos());
        
1144
        s.skip(-1 * s.pos());
1145 1146 1147 1148 1149 1150 1151 1152 1153 1154
        EXPECT_EQ(0x0a, s.read_1bytes());
        EXPECT_EQ(0x00, s.read_4bytes());
    }
    
    if (true) {
        o = SrsAmf0Any::strict_array();
        SrsAutoFree(SrsAmf0StrictArray, o);
        
        o->append(SrsAmf0Any::number(0));
        
1155
        s.skip(-1 * s.pos());
1156 1157 1158 1159
        EXPECT_EQ(ERROR_SUCCESS, o->write(&s));
        EXPECT_EQ(5 + SrsAmf0Size::number(), s.pos());
    }
}
winlin authored
1160
1161 1162 1163
/**
* object has object property, 
*/
winlin authored
1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187
VOID TEST(ProtocolAMF0Test, ObjectObjectObject)
{
    SrsAmf0Any* obj = SrsAmf0Any::object();
    SrsAutoFree(SrsAmf0Any, obj);
    EXPECT_EQ(0, obj->to_object()->count());
    
    SrsAmf0Any* child1 = SrsAmf0Any::object();
    obj->to_object()->set("child1", child1);
    EXPECT_EQ(1, obj->to_object()->count());
    EXPECT_EQ(0, child1->to_object()->count());
    
    SrsAmf0Any* child2 = SrsAmf0Any::object();
    child1->to_object()->set("child2", child2);
    EXPECT_EQ(1, obj->to_object()->count());
    EXPECT_EQ(1, child1->to_object()->count());
    EXPECT_EQ(0, child2->to_object()->count());
    
    SrsAmf0Any* child3 = SrsAmf0Any::object();
    child2->to_object()->set("child3", child3);
    EXPECT_EQ(1, obj->to_object()->count());
    EXPECT_EQ(1, child1->to_object()->count());
    EXPECT_EQ(1, child2->to_object()->count());
    EXPECT_EQ(0, child3->to_object()->count());
}
1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272

/**
* ecma array has ecma array property, 
*/
VOID TEST(ProtocolAMF0Test, EcmaEcmaEcma)
{
    SrsAmf0Any* arr = SrsAmf0Any::ecma_array();
    SrsAutoFree(SrsAmf0Any, arr);
    EXPECT_EQ(0, arr->to_ecma_array()->count());
    
    SrsAmf0Any* arr1 = SrsAmf0Any::ecma_array();
    arr->to_ecma_array()->set("child1", arr1);
    EXPECT_EQ(1, arr->to_ecma_array()->count());
    EXPECT_EQ(0, arr1->to_ecma_array()->count());
    
    SrsAmf0Any* arr2 = SrsAmf0Any::ecma_array();
    arr1->to_ecma_array()->set("child2", arr2);
    EXPECT_EQ(1, arr->to_ecma_array()->count());
    EXPECT_EQ(1, arr1->to_ecma_array()->count());
    EXPECT_EQ(0, arr2->to_ecma_array()->count());
    
    SrsAmf0Any* arr3 = SrsAmf0Any::ecma_array();
    arr2->to_ecma_array()->set("child3", arr3);
    EXPECT_EQ(1, arr->to_ecma_array()->count());
    EXPECT_EQ(1, arr1->to_ecma_array()->count());
    EXPECT_EQ(1, arr2->to_ecma_array()->count());
    EXPECT_EQ(0, arr3->to_ecma_array()->count());
}

/**
* strict array contains strict array
*/
VOID TEST(ProtocolAMF0Test, StrictStrictStrict)
{
    SrsAmf0Any* arr = SrsAmf0Any::strict_array();
    SrsAutoFree(SrsAmf0Any, arr);
    EXPECT_EQ(0, arr->to_strict_array()->count());
    
    SrsAmf0Any* arr1 = SrsAmf0Any::strict_array();
    arr->to_strict_array()->append(arr1);
    EXPECT_EQ(1, arr->to_strict_array()->count());
    EXPECT_EQ(0, arr1->to_strict_array()->count());
    
    SrsAmf0Any* arr2 = SrsAmf0Any::strict_array();
    arr1->to_strict_array()->append(arr2);
    EXPECT_EQ(1, arr->to_strict_array()->count());
    EXPECT_EQ(1, arr1->to_strict_array()->count());
    EXPECT_EQ(0, arr2->to_strict_array()->count());
    
    SrsAmf0Any* arr3 = SrsAmf0Any::strict_array();
    arr2->to_strict_array()->append(arr3);
    EXPECT_EQ(1, arr->to_strict_array()->count());
    EXPECT_EQ(1, arr1->to_strict_array()->count());
    EXPECT_EQ(1, arr2->to_strict_array()->count());
    EXPECT_EQ(0, arr3->to_strict_array()->count());
}

/**
* object has ecma array property,
* where ecma array contains strict array.
*/
VOID TEST(ProtocolAMF0Test, ObjectEcmaStrict)
{
    SrsAmf0Any* obj = SrsAmf0Any::object();
    SrsAutoFree(SrsAmf0Any, obj);
    EXPECT_EQ(0, obj->to_object()->count());
    
    SrsAmf0Any* arr1 = SrsAmf0Any::ecma_array();
    obj->to_object()->set("child1", arr1);
    EXPECT_EQ(1, obj->to_object()->count());
    EXPECT_EQ(0, arr1->to_ecma_array()->count());
    
    SrsAmf0Any* arr2 = SrsAmf0Any::strict_array();
    arr1->to_ecma_array()->set("child2", arr2);
    EXPECT_EQ(1, obj->to_object()->count());
    EXPECT_EQ(1, arr1->to_ecma_array()->count());
    EXPECT_EQ(0, arr2->to_strict_array()->count());
    
    SrsAmf0Any* arr3 = SrsAmf0Any::ecma_array();
    arr2->to_strict_array()->append(arr3);
    EXPECT_EQ(1, obj->to_object()->count());
    EXPECT_EQ(1, arr1->to_ecma_array()->count());
    EXPECT_EQ(1, arr2->to_strict_array()->count());
    EXPECT_EQ(0, arr3->to_ecma_array()->count());
}
1273
winlin authored
1274 1275
#endif