fifo_test.cc revision 8bcbed890bc3ce4d7a057a8f32cab53fa534672e
1/* Copyright (c) 2013 The Chromium Authors. All rights reserved. 2 * Use of this source code is governed by a BSD-style license that can be 3 * found in the LICENSE file. 4 */ 5 6#include <errno.h> 7#include <fcntl.h> 8#include <pthread.h> 9#include <stdio.h> 10#include <sys/ioctl.h> 11#include <sys/stat.h> 12#include <sys/time.h> 13 14#include "gtest/gtest.h" 15 16#include "nacl_io/fifo_char.h" 17#include "nacl_io/fifo_null.h" 18#include "nacl_io/fifo_packet.h" 19#include "nacl_io/packet.h" 20 21#include "ppapi_simple/ps.h" 22 23using namespace nacl_io; 24 25namespace { 26const size_t kTestSize = 32; 27const size_t kHalfSize = kTestSize / 2; 28const size_t kQuarterSize = kTestSize / 4; 29}; 30 31TEST(FIFONull, Basic) { 32 FIFONull fifo; 33 EXPECT_FALSE(fifo.IsFull()); 34 EXPECT_FALSE(fifo.IsEmpty()); 35 36 EXPECT_LT(0, fifo.ReadAvailable()); 37 EXPECT_LT(0, fifo.WriteAvailable()); 38} 39 40/** 41 * Test writes that start a wrapped location. We had 42 * a bug where writes that wrapped around were fine but 43 * bytes that started at a wrapped location were being 44 * written to the wrong loction. 45 */ 46TEST(FIFOChar, WriteWrapped) { 47 char temp_wr[kTestSize * 2]; 48 char temp_rd[kTestSize * 2]; 49 size_t wr_offs = 0; 50 size_t rd_offs = 0; 51 52 memset(temp_rd, 0, sizeof(temp_rd)); 53 for (size_t index = 0; index < sizeof(temp_wr); index++) 54 temp_wr[index] = index; 55 56 FIFOChar fifo(kTestSize); 57 58 // Fill the fifo 59 wr_offs += fifo.Write(temp_wr + wr_offs, kTestSize); 60 EXPECT_EQ(kTestSize, wr_offs); 61 62 // Read 1/2 of it 63 rd_offs += fifo.Read(temp_rd + rd_offs, kHalfSize); 64 EXPECT_EQ(kHalfSize, rd_offs); 65 66 // Write the next two quaters. The second 67 // of these calls to write start at a wrapped 68 // location 1/4 of the way into the fifo 69 wr_offs += fifo.Write(temp_wr + wr_offs, kQuarterSize); 70 EXPECT_EQ(kTestSize + kQuarterSize, wr_offs); 71 wr_offs += fifo.Write(temp_wr + wr_offs, kQuarterSize); 72 EXPECT_EQ(kTestSize + kHalfSize, wr_offs); 73 74 // Finally read all the bytes we wrote. 75 rd_offs += fifo.Read(temp_rd + rd_offs, kTestSize); 76 EXPECT_EQ(kTestSize + kHalfSize, rd_offs); 77 78 for (size_t i = 0; i < rd_offs; i++) 79 ASSERT_EQ((char)i, temp_rd[i]) << "fifo mismatch at pos:" << i; 80} 81 82TEST(FIFOChar, Wrap) { 83 char temp_wr[kTestSize * 2]; 84 char temp_rd[kTestSize * 2]; 85 size_t wr_offs = 0; 86 size_t rd_offs = 0; 87 88 FIFOChar fifo(kTestSize); 89 90 memset(temp_rd, 0, sizeof(temp_rd)); 91 for (size_t index = 0; index < sizeof(temp_wr); index++) 92 temp_wr[index] = index; 93 94 EXPECT_TRUE(fifo.IsEmpty()); 95 EXPECT_FALSE(fifo.IsFull()); 96 97 // Wrap read and write differently, and verify copy is correct 98 EXPECT_EQ(0, fifo.ReadAvailable()); 99 EXPECT_EQ(kTestSize, fifo.WriteAvailable()); 100 101 wr_offs += fifo.Write(temp_wr, kHalfSize); 102 EXPECT_EQ(kHalfSize, wr_offs); 103 104 EXPECT_FALSE(fifo.IsEmpty()); 105 EXPECT_FALSE(fifo.IsFull()); 106 107 rd_offs += fifo.Read(temp_rd, kQuarterSize); 108 EXPECT_EQ(kQuarterSize, rd_offs); 109 110 EXPECT_FALSE(fifo.IsEmpty()); 111 EXPECT_FALSE(fifo.IsFull()); 112 113 wr_offs += fifo.Write(&temp_wr[wr_offs], kTestSize); 114 EXPECT_EQ(kTestSize + kQuarterSize, wr_offs); 115 116 EXPECT_FALSE(fifo.IsEmpty()); 117 118 rd_offs += fifo.Read(&temp_rd[rd_offs], kTestSize); 119 EXPECT_EQ(kTestSize + kQuarterSize, rd_offs); 120 121 EXPECT_TRUE(fifo.IsEmpty()); 122 EXPECT_FALSE(fifo.IsFull()); 123 124 for (size_t index = 0; index < kQuarterSize + kTestSize; index++) 125 EXPECT_EQ((char) index, temp_rd[index]); 126} 127 128TEST(FIFOPacket, Packets) { 129 char temp_wr[kTestSize]; 130 FIFOPacket fifo(kTestSize); 131 132 Packet* pkt0 = new Packet(NULL); 133 Packet* pkt1 = new Packet(NULL); 134 pkt0->Copy(temp_wr, kHalfSize, 0); 135 pkt1->Copy(temp_wr, kTestSize, 0); 136 137 EXPECT_TRUE(fifo.IsEmpty()); 138 EXPECT_FALSE(fifo.IsFull()); 139 140 EXPECT_EQ(0, fifo.ReadAvailable()); 141 EXPECT_EQ(kTestSize, fifo.WriteAvailable()); 142 143 fifo.WritePacket(pkt0); 144 EXPECT_FALSE(fifo.IsEmpty()); 145 EXPECT_FALSE(fifo.IsFull()); 146 147 EXPECT_EQ(kHalfSize, fifo.ReadAvailable()); 148 EXPECT_EQ(kHalfSize, fifo.WriteAvailable()); 149 150 fifo.WritePacket(pkt1); 151 EXPECT_FALSE(fifo.IsEmpty()); 152 EXPECT_TRUE(fifo.IsFull()); 153 154 EXPECT_EQ(kHalfSize + kTestSize, fifo.ReadAvailable()); 155 EXPECT_EQ(0, fifo.WriteAvailable()); 156 157 EXPECT_EQ(pkt0, fifo.ReadPacket()); 158 EXPECT_FALSE(fifo.IsEmpty()); 159 EXPECT_TRUE(fifo.IsFull()); 160 161 EXPECT_EQ(kTestSize, fifo.ReadAvailable()); 162 EXPECT_EQ(0, fifo.WriteAvailable()); 163 164 EXPECT_EQ(pkt1, fifo.ReadPacket()); 165 166 EXPECT_TRUE(fifo.IsEmpty()); 167 EXPECT_FALSE(fifo.IsFull()); 168 169 EXPECT_EQ(0, fifo.ReadAvailable()); 170 EXPECT_EQ(kTestSize, fifo.WriteAvailable()); 171 172} 173