1/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.internal.util;
18
19import android.test.AndroidTestCase;
20
21import java.io.ByteArrayInputStream;
22import java.io.IOException;
23import java.nio.charset.StandardCharsets;
24
25/**
26 * Tests for {@link ProcFileReader}.
27 */
28public class ProcFileReaderTest extends AndroidTestCase {
29
30    public void testEmpty() throws Exception {
31        final ProcFileReader reader = buildReader("");
32
33        assertFalse(reader.hasMoreData());
34        try {
35            reader.finishLine();
36            fail("somehow finished line beyond end of stream?");
37        } catch (IOException e) {
38            // expected
39        }
40        assertFalse(reader.hasMoreData());
41    }
42
43    public void testSingleString() throws Exception {
44        final ProcFileReader reader = buildReader("a\nb\nc\n");
45
46        assertEquals("a", reader.nextString());
47        reader.finishLine();
48        assertTrue(reader.hasMoreData());
49
50        assertEquals("b", reader.nextString());
51        reader.finishLine();
52        assertTrue(reader.hasMoreData());
53
54        assertEquals("c", reader.nextString());
55        reader.finishLine();
56        assertFalse(reader.hasMoreData());
57    }
58
59    public void testMixedNumbersSkip() throws Exception {
60        final ProcFileReader reader = buildReader("1 2 3\n4 abc_def 5 6 7 8 9\n10\n");
61
62        assertEquals(1, reader.nextInt());
63        assertEquals(2, reader.nextInt());
64        assertEquals(3, reader.nextInt());
65        reader.finishLine();
66        assertTrue(reader.hasMoreData());
67
68        assertEquals(4, reader.nextInt());
69        assertEquals("abc_def", reader.nextString());
70        assertEquals(5, reader.nextInt());
71        reader.finishLine();
72        assertTrue(reader.hasMoreData());
73
74        assertEquals(10, reader.nextInt());
75        reader.finishLine();
76        assertFalse(reader.hasMoreData());
77    }
78
79    public void testBufferSize() throws Exception {
80        // read numbers using very small buffer size, exercising fillBuf()
81        final ProcFileReader reader = buildReader("1 21 3 41 5 61 7 81 9 10\n", 3);
82
83        assertEquals(1, reader.nextInt());
84        assertEquals(21, reader.nextInt());
85        assertEquals(3, reader.nextInt());
86        assertEquals(41, reader.nextInt());
87        assertEquals(5, reader.nextInt());
88        assertEquals(61, reader.nextInt());
89        assertEquals(7, reader.nextInt());
90        assertEquals(81, reader.nextInt());
91        assertEquals(9, reader.nextInt());
92        assertEquals(10, reader.nextInt());
93        reader.finishLine();
94        assertFalse(reader.hasMoreData());
95    }
96
97    public void testBlankLines() throws Exception {
98        final ProcFileReader reader = buildReader("1\n\n2\n\n3\n");
99
100        assertEquals(1, reader.nextInt());
101        reader.finishLine();
102        assertTrue(reader.hasMoreData());
103        reader.finishLine();
104        assertTrue(reader.hasMoreData());
105
106        assertEquals(2, reader.nextInt());
107        reader.finishLine();
108        assertTrue(reader.hasMoreData());
109        reader.finishLine();
110        assertTrue(reader.hasMoreData());
111
112        assertEquals(3, reader.nextInt());
113        reader.finishLine();
114        assertFalse(reader.hasMoreData());
115    }
116
117    public void testMinMax() throws Exception {
118        final ProcFileReader reader = buildReader(
119                "1 -1024 9223372036854775807 -9223372036854775808\n");
120
121        assertEquals(1, reader.nextLong());
122        assertEquals(-1024, reader.nextLong());
123        assertEquals(Long.MAX_VALUE, reader.nextLong());
124        assertEquals(Long.MIN_VALUE, reader.nextLong());
125        reader.finishLine();
126        assertFalse(reader.hasMoreData());
127    }
128
129    public void testDelimiterNeverFound() throws Exception {
130        final ProcFileReader reader = buildReader("teststringwithoutdelimiters");
131
132        try {
133            reader.nextString();
134            fail("somehow read a string value?");
135        } catch (IOException e) {
136            // expected
137            assertTrue(e.getMessage().contains("End of stream"));
138        }
139    }
140
141    public void testLargerThanBuffer() throws Exception {
142        // try finishing line larger than buffer
143        final ProcFileReader reader = buildReader("1 teststringlongerthanbuffer\n", 4);
144
145        assertEquals(1, reader.nextLong());
146        try {
147            reader.finishLine();
148            fail("somehow finished line?");
149        } catch (IOException e) {
150            // expected
151            assertTrue(e.getMessage().contains("already-full buffer"));
152        }
153    }
154
155    public void testOptionalLongs() throws Exception {
156        final ProcFileReader reader = buildReader("123 456\n789\n");
157
158        assertEquals(123L, reader.nextLong());
159        assertEquals(456L, reader.nextOptionalLong(-1L));
160        assertEquals(-1L, reader.nextOptionalLong(-1L));
161        assertEquals(-1L, reader.nextOptionalLong(-1L));
162        assertEquals(-1L, reader.nextOptionalLong(-1L));
163        reader.finishLine();
164
165        assertEquals(789L, reader.nextOptionalLong(-1L));
166        assertEquals(-1L, reader.nextOptionalLong(-1L));
167    }
168
169    private static ProcFileReader buildReader(String string) throws IOException {
170        return buildReader(string, 2048);
171    }
172
173    private static ProcFileReader buildReader(String string, int bufferSize) throws IOException {
174        return new ProcFileReader(
175                new ByteArrayInputStream(string.getBytes(StandardCharsets.US_ASCII)), bufferSize);
176    }
177}
178