1 /*
2  * Copyright (C) 2020 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 
17 package com.android.ims.rcs.uce.presence.pidfparser.pidf;
18 
19 import static org.junit.Assert.assertEquals;
20 import static org.junit.Assert.assertNotNull;
21 import static org.junit.Assert.assertTrue;
22 
23 import androidx.test.ext.junit.runners.AndroidJUnit4;
24 import androidx.test.filters.SmallTest;
25 
26 import com.android.ims.ImsTestBase;
27 import com.android.ims.rcs.uce.presence.pidfparser.ElementBase;
28 import com.android.ims.rcs.uce.presence.pidfparser.PidfParserConstant;
29 import com.android.ims.rcs.uce.presence.pidfparser.PidfParserUtils;
30 import com.android.ims.rcs.uce.presence.pidfparser.capabilities.Audio;
31 import com.android.ims.rcs.uce.presence.pidfparser.capabilities.CapsConstant;
32 import com.android.ims.rcs.uce.presence.pidfparser.capabilities.Duplex;
33 import com.android.ims.rcs.uce.presence.pidfparser.capabilities.ServiceCaps;
34 import com.android.ims.rcs.uce.presence.pidfparser.capabilities.Video;
35 import com.android.ims.rcs.uce.presence.pidfparser.omapres.Description;
36 import com.android.ims.rcs.uce.presence.pidfparser.omapres.OmaPresConstant;
37 import com.android.ims.rcs.uce.presence.pidfparser.omapres.ServiceDescription;
38 import com.android.ims.rcs.uce.presence.pidfparser.omapres.ServiceId;
39 import com.android.ims.rcs.uce.presence.pidfparser.omapres.Version;
40 
41 import java.io.IOException;
42 import java.io.Reader;
43 import java.io.StringReader;
44 import java.io.StringWriter;
45 import java.time.Instant;
46 import java.util.List;
47 
48 import org.junit.After;
49 import org.junit.Before;
50 import org.junit.Test;
51 import org.junit.runner.RunWith;
52 import org.xmlpull.v1.XmlPullParser;
53 import org.xmlpull.v1.XmlPullParserException;
54 import org.xmlpull.v1.XmlPullParserFactory;
55 import org.xmlpull.v1.XmlSerializer;
56 
57 @RunWith(AndroidJUnit4.class)
58 public class TupleTest extends ImsTestBase {
59 
60     @Before
setUp()61     public void setUp() throws Exception {
62         super.setUp();
63     }
64 
65     @After
tearDown()66     public void tearDown() throws Exception {
67         super.tearDown();
68     }
69 
70     @Test
71     @SmallTest
testElementName()72     public void testElementName() throws Exception {
73         Tuple tuple = new Tuple();
74 
75         assertEquals(PidfConstant.NAMESPACE, tuple.getNamespace());
76         assertEquals(Tuple.ELEMENT_NAME, tuple.getElementName());
77     }
78 
79     @Test
80     @SmallTest
testSerializing()81     public void testSerializing() throws Exception {
82         Tuple tuple = new Tuple();
83 
84         Basic basic = new Basic(Basic.OPEN);
85         Status status = new Status();
86         status.setBasic(basic);
87         tuple.setStatus(status);
88 
89         ServiceId serviceId = new ServiceId("service_id_001");
90         Version version = new Version(1, 0);
91         Description description = new Description("description test");
92         ServiceDescription serviceDescription = new ServiceDescription();
93         serviceDescription.setServiceId(serviceId);
94         serviceDescription.setVersion(version);
95         serviceDescription.setDescription(description);
96         tuple.setServiceDescription(serviceDescription);
97 
98         Audio audio = new Audio(true);
99         Video video = new Video(true);
100         Duplex duplex = new Duplex();
101         duplex.addSupportedType(Duplex.DUPLEX_FULL);
102 
103         ServiceCaps serviceCaps = new ServiceCaps();
104         serviceCaps.addElement(audio);
105         serviceCaps.addElement(video);
106         serviceCaps.addElement(duplex);
107         tuple.setServiceCaps(serviceCaps);
108 
109         Note note = new Note("Note test");
110         tuple.addNote(note);
111 
112         String nowTime = Instant.now().toString();
113         Timestamp timestamp = new Timestamp(nowTime);
114         tuple.setTimestamp(timestamp);
115 
116         StringWriter writer = new StringWriter();
117         XmlSerializer serializer = getXmlSerializer(writer);
118 
119         // Serializing
120         serializer.startDocument(PidfParserConstant.ENCODING_UTF_8, true);
121         tuple.serialize(serializer);
122         serializer.endDocument();
123         serializer.flush();
124 
125         String result = writer.toString();
126 
127         String verificationStatus = "<status><basic>open</basic></status>";
128         String verificationServiceId = "<op:service-id>service_id_001</op:service-id>";
129         String verificationVersion = "<op:version>1.0</op:version>";
130         String verificationDescription = "<op:description>description test</op:description>";
131         String verificationAudio = "<caps:audio>true</caps:audio>";
132         String verificationVideo = "<caps:video>true</caps:video>";
133         String verificationNote = "<note>Note test</note>";
134         String verificationTimestamp = "<timestamp>" + nowTime + "</timestamp>";
135 
136         assertTrue(result.contains(verificationStatus));
137         assertTrue(result.contains(verificationServiceId));
138         assertTrue(result.contains(verificationVersion));
139         assertTrue(result.contains(verificationDescription));
140         assertTrue(result.contains(verificationAudio));
141         assertTrue(result.contains(verificationVideo));
142         assertTrue(result.contains(verificationNote));
143         assertTrue(result.contains(verificationTimestamp));
144     }
145 
146     @Test
147     @SmallTest
testParsing()148     public void testParsing() throws Exception {
149         final String status = Basic.OPEN;
150         final String serviceId = "service_id_001";
151         final String version = "1.0";
152         final String description = "description test";
153         final boolean audio = true;
154         final boolean video = true;
155         final String note = "note test";
156         final String nowTime = Instant.now().toString();
157 
158         StringBuilder tupleExample = new StringBuilder();
159         tupleExample.append("<?xml version='1.0' encoding='utf-8' standalone='yes' ?>")
160                 .append("<tuple id=\"tid0\" xmlns=\"urn:ietf:params:xml:ns:pidf\"")
161                 .append(" xmlns:op=\"urn:oma:xml:prs:pidf:oma-pres\"")
162                 .append(" xmlns:caps=\"urn:ietf:params:xml:ns:pidf:caps\">")
163                 .append("<status><basic>").append(status).append("</basic></status>")
164                 .append("<op:service-description>")
165                 .append("<op:service-id>").append(serviceId).append("</op:service-id>")
166                 .append("<op:version>").append(version).append("</op:version>")
167                 .append("<op:description>").append(description).append("</op:description>")
168                 .append("</op:service-description>")
169                 .append("<caps:servcaps><caps:audio>").append(audio).append("</caps:audio>")
170                 .append("<caps:video>").append(video).append("</caps:video>")
171                 .append("<caps:duplex><caps:supported>")
172                 .append("<caps:full />")
173                 .append("</caps:supported></caps:duplex>")
174                 .append("</caps:servcaps>")
175                 .append("<note>").append(note).append("</note>")
176                 .append("<timestamp>").append(nowTime).append("</timestamp></tuple>");
177 
178         XmlPullParser parser = XmlPullParserFactory.newInstance().newPullParser();
179         parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, true);
180         Reader reader = new StringReader(tupleExample.toString());
181         parser.setInput(reader);
182 
183         Tuple tuple = null;
184         int nextType = parser.next();
185 
186         // Find the start tag
187         do {
188             if (nextType == XmlPullParser.START_TAG
189                     && Tuple.ELEMENT_NAME.equals(parser.getName())) {
190                 tuple = new Tuple();
191                 tuple.parse(parser);
192                 break;
193             }
194             nextType = parser.next();
195         } while(nextType != XmlPullParser.END_DOCUMENT);
196 
197         reader.close();
198 
199         assertNotNull(tuple);
200         assertEquals(Basic.OPEN, PidfParserUtils.getTupleStatus(tuple));
201         assertEquals(serviceId, PidfParserUtils.getTupleServiceId(tuple));
202         assertEquals(version, PidfParserUtils.getTupleServiceVersion(tuple));
203         assertEquals(description, PidfParserUtils.getTupleServiceDescription(tuple));
204 
205         boolean resultAudio = false;
206         boolean resultVideo = false;
207         List<ElementBase> elements = tuple.getServiceCaps().getElements();
208         for (ElementBase element : elements) {
209             if (element instanceof Audio) {
210                 resultAudio = ((Audio) element).isAudioSupported();
211             } else if (element instanceof Video) {
212                 resultVideo = ((Video) element).isVideoSupported();
213             }
214         }
215         assertTrue(resultAudio);
216         assertTrue(resultVideo);
217 
218         String resultNote = null;
219         List<Note> noteList = tuple.getNoteList();
220         if (noteList != null && !noteList.isEmpty()) {
221             Note eachNote = noteList.get(0);
222             if (eachNote != null) {
223                 resultNote = eachNote.getNote();
224             }
225         }
226 
227         assertTrue(note.equals(resultNote));
228         assertEquals(nowTime, PidfParserUtils.getTupleTimestamp(tuple));
229     }
230 
getXmlSerializer(StringWriter writer)231     private XmlSerializer getXmlSerializer(StringWriter writer)
232             throws XmlPullParserException, IOException {
233         XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
234         XmlSerializer serializer = factory.newSerializer();
235         serializer.setOutput(writer);
236         serializer.setPrefix("", PidfConstant.NAMESPACE);
237         serializer.setPrefix("op", OmaPresConstant.NAMESPACE);
238         serializer.setPrefix("caps", CapsConstant.NAMESPACE);
239         return serializer;
240     }
241 }
242