1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
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
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
|
/*
* Copyright (C) 2012 The Android Open Source Project
*
* Licensed under the Eclipse Public License, Version 1.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.eclipse.org/org/documents/epl-v10.php
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.sdklib.internal.repository.sources;
import com.android.sdklib.internal.repository.ITaskMonitor;
import com.android.sdklib.internal.repository.MockMonitor;
import com.android.sdklib.internal.repository.packages.Package;
import com.android.sdklib.internal.repository.packages.SystemImagePackage;
import com.android.sdklib.repository.SdkSysImgConstants;
import org.w3c.dom.Document;
import java.io.ByteArrayInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import junit.framework.TestCase;
/**
* Tests for {@link SdkSysImgSource}.
*/
public class SdkSysImgSourceTest extends TestCase {
/**
* An internal helper class to give us visibility to the protected members we want
* to test.
*/
private static class MockSdkSysImgSource extends SdkSysImgSource {
public MockSdkSysImgSource() {
super("fake-url", null /*uiName*/);
}
public Document _findAlternateToolsXml(InputStream xml) {
return super.findAlternateToolsXml(xml);
}
public boolean _parsePackages(Document doc, String nsUri, ITaskMonitor monitor) {
return super.parsePackages(doc, nsUri, monitor);
}
public int _getXmlSchemaVersion(InputStream xml) {
return super.getXmlSchemaVersion(xml);
}
public String _validateXml(InputStream xml, String url, int version,
String[] outError, Boolean[] validatorFound) {
return super.validateXml(xml, url, version, outError, validatorFound);
}
public Document _getDocument(InputStream xml, ITaskMonitor monitor) {
return super.getDocument(xml, monitor);
}
}
private MockSdkSysImgSource mSource;
@Override
protected void setUp() throws Exception {
super.setUp();
mSource = new MockSdkSysImgSource();
}
@Override
protected void tearDown() throws Exception {
super.tearDown();
mSource = null;
}
/**
* Validate that findAlternateToolsXml doesn't work for this source even
* when trying to load a valid xml. That's because finding alternate tools
* is not supported by this kind of source.
*/
public void testFindAlternateToolsXml_1() throws Exception {
InputStream xmlStream =
getTestResource("/com/android/sdklib/testdata/sys_img_sample_1.xml");
Document result = mSource._findAlternateToolsXml(xmlStream);
assertNull(result);
}
/**
* Validate we can load a valid schema version 1
*/
public void testLoadSysImgXml_1() throws Exception {
InputStream xmlStream =
getTestResource("/com/android/sdklib/testdata/sys_img_sample_1.xml");
// guess the version from the XML document
int version = mSource._getXmlSchemaVersion(xmlStream);
assertEquals(1, version);
Boolean[] validatorFound = new Boolean[] { Boolean.FALSE };
String[] validationError = new String[] { null };
String url = "not-a-valid-url://" + SdkSysImgConstants.URL_DEFAULT_FILENAME;
String uri = mSource._validateXml(xmlStream, url, version, validationError, validatorFound);
assertEquals(Boolean.TRUE, validatorFound[0]);
assertEquals(null, validationError[0]);
assertEquals(SdkSysImgConstants.getSchemaUri(1), uri);
// Validation was successful, load the document
MockMonitor monitor = new MockMonitor();
Document doc = mSource._getDocument(xmlStream, monitor);
assertNotNull(doc);
// Get the packages
assertTrue(mSource._parsePackages(doc, uri, monitor));
assertEquals(
"Found Intel x86 Atom System Image, Android API 2, revision 1\n" +
"Found ARM EABI v7a System Image, Android API 2, revision 2\n" +
"Found ARM EABI System Image, Android API 42, revision 12\n" +
"Found MIPS System Image, Android API 42, revision 12\n",
monitor.getCapturedVerboseLog());
assertEquals("", monitor.getCapturedLog());
assertEquals("", monitor.getCapturedErrorLog());
// check the packages we found...
// Note the order doesn't necessary match the one from the
// assertEquald(getCapturedVerboseLog) because packages are sorted using the
// Packages' sorting order, e.g. all platforms are sorted by descending API level, etc.
Package[] pkgs = mSource.getPackages();
assertEquals(4, pkgs.length);
for (Package p : pkgs) {
// We expected to find packages with each at least one archive.
assertTrue(p.getArchives().length >= 1);
// And only system images are supported by this source
assertTrue(p instanceof SystemImagePackage);
}
// Check the system-image packages
ArrayList<String> sysImgVersionAbi = new ArrayList<String>();
for (Package p : pkgs) {
if (p instanceof SystemImagePackage) {
SystemImagePackage sip = (SystemImagePackage) p;
String v = sip.getAndroidVersion().getApiString();
String a = sip.getAbi();
sysImgVersionAbi.add(String.format("%1$s %2$s", v, a)); //$NON-NLS-1$
}
}
assertEquals(
"[42 armeabi, " +
"42 mips, " +
"2 armeabi-v7a, " +
"2 x86]",
Arrays.toString(sysImgVersionAbi.toArray()));
}
//-----
/**
* Returns an SdkLib file resource as a {@link ByteArrayInputStream},
* which has the advantage that we can use {@link InputStream#reset()} on it
* at any time to read it multiple times.
* <p/>
* The default for getResourceAsStream() is to return a {@link FileInputStream} that
* does not support reset(), yet we need it in the tested code.
*
* @throws IOException if some I/O read fails
*/
private ByteArrayInputStream getTestResource(String filename) throws IOException {
InputStream xmlStream = this.getClass().getResourceAsStream(filename);
try {
byte[] data = new byte[8192];
int offset = 0;
int n;
while ((n = xmlStream.read(data, offset, data.length - offset)) != -1) {
offset += n;
if (offset == data.length) {
byte[] newData = new byte[offset + 8192];
System.arraycopy(data, 0, newData, 0, offset);
data = newData;
}
}
return new ByteArrayInputStream(data, 0, offset);
} finally {
if (xmlStream != null) {
xmlStream.close();
}
}
}
}
|
