src/unittest/circlebuf.cc

   1 /*
   2  * Copyright (c) 2015 ARM Limited
   3  * All rights reserved
   4  *
   5  * The license below extends only to copyright in the software and shall
   6  * not be construed as granting a license to any other intellectual
   7  * property including but not limited to intellectual property relating
   8  * to a hardware implementation of the functionality of the software
   9  * licensed hereunder.  You may use the software subject to the license
  10  * terms below provided that you ensure that this notice is replicated
  11  * unmodified and in its entirety in all distributions of the software,
  12  * modified or unmodified, in source code or in binary form.
  13  *
  14  * Redistribution and use in source and binary forms, with or without
  15  * modification, are permitted provided that the following conditions are
  16  * met: redistributions of source code must retain the above copyright
  17  * notice, this list of conditions and the following disclaimer;
  18  * redistributions in binary form must reproduce the above copyright
  19  * notice, this list of conditions and the following disclaimer in the
  20  * documentation and/or other materials provided with the distribution;
  21  * neither the name of the copyright holders nor the names of its
  22  * contributors may be used to endorse or promote products derived from
  23  * this software without specific prior written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  26  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  27  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  28  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  29  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  30  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  31  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  32  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  33  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  34  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  35  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36  *
  37  * Authors: Andreas Sandberg
  38  */
  39
  40 #include "base/circlebuf.hh"
  41 #include "unittest/unittest.hh"
  42
  43 const char data[] = {
  44     0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7,
  45     0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf,
  46 };
  47
  48 int
  49 main(int argc, char *argv[])
  50 {
  51     UnitTest::setCase("Basic non-overflow functionality");
  52     {
  53         CircleBuf<char> buf(8);
  54         char foo[16];
  55
  56         // Write empty buffer, no overflow
  57         buf.write(data, 8);
  58         EXPECT_EQ(buf.size(), 8);
  59         buf.peek(foo, 8);
  60         EXPECT_EQ(memcmp(foo, data, 8), 0);
  61
  62         // Read 2
  63         buf.read(foo, 2);
  64         EXPECT_EQ(memcmp(foo, data, 2), 0);
  65         EXPECT_EQ(buf.size(), 6);
  66         buf.read(foo, 6);
  67         EXPECT_EQ(memcmp(foo, data + 2, 6), 0);
  68         EXPECT_EQ(buf.size(), 0);
  69     }
  70
  71     UnitTest::setCase("Basic single write overflow functionality");
  72     {
  73         CircleBuf<char> buf(8);
  74         char foo[16];
  75
  76         buf.write(data, 16);
  77         EXPECT_EQ(buf.size(), 8);
  78         buf.peek(foo, 8);
  79         EXPECT_EQ(memcmp(data + 8, foo, 8), 0);
  80     }
  81
  82
  83     UnitTest::setCase("Multi-write overflow functionality");
  84     {
  85         CircleBuf<char> buf(8);
  86         char foo[16];
  87
  88         // Write, no overflow, write overflow
  89         buf.write(data, 6);
  90         buf.write(data + 8, 6);
  91         EXPECT_EQ(buf.size(), 8);
  92         buf.peek(foo, 8);
  93         EXPECT_EQ(memcmp(data + 4, foo, 2), 0);
  94         EXPECT_EQ(memcmp(data + 8, foo + 2, 6), 0);
  95     }
  96
  97     UnitTest::setCase("Pointer wrap around");
  98     {
  99         CircleBuf<char> buf(8);
 100         char foo[16];
 101
 102         // _start == 0, _stop = 8
 103         buf.write(data, 8);
 104         // _start == 4, _stop = 8
 105         buf.read(foo, 4);
 106         // _start == 4, _stop = 12
 107         buf.write(data + 8, 4);
 108         EXPECT_EQ(buf.size(), 8);
 109         // _start == 10, _stop = 12
 110         // Normalized: _start == 2, _stop = 4
 111         buf.read(foo + 4, 6);
 112         EXPECT_EQ(buf.size(), 2);
 113         EXPECT_EQ(memcmp(data, foo, 10), 0);
 114         // Normalized: _start == 4, _stop = 4
 115         buf.read(foo + 10, 2);
 116         EXPECT_EQ(buf.size(), 0);
 117         EXPECT_EQ(memcmp(data, foo, 12), 0);
 118     }
 119
 120     return UnitTest::printResults();
 121 }