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 android.view
18 
19 import android.view.InputDevice.SOURCE_KEYBOARD
20 import android.view.KeyEvent.ACTION_DOWN
21 import android.os.Parcel
22 
23 import androidx.test.ext.junit.runners.AndroidJUnit4
24 import androidx.test.filters.SmallTest
25 
26 import org.junit.Assert.assertEquals
27 import org.junit.Assert.assertTrue
28 import org.junit.runner.RunWith
29 import org.junit.Test
30 
31 @RunWith(AndroidJUnit4::class)
32 @SmallTest
33 class VerifiedKeyEventTest {
34 
35     @Test
36     fun testConstructor() {
37         val event = createVerifiedKeyEvent()
38 
39         assertEquals(DEVICE_ID, event.deviceId)
40         assertEquals(EVENT_TIME_NANOS, event.eventTimeNanos)
41         assertEquals(SOURCE, event.source)
42         assertEquals(DISPLAY_ID, event.displayId)
43 
44         assertEquals(ACTION, event.action)
45         assertEquals(DOWN_TIME_NANOS, event.downTimeNanos)
46         assertEquals(FLAGS, event.flags)
47         assertEquals(KEY_CODE, event.keyCode)
48         assertEquals(SCAN_CODE, event.scanCode)
49         assertEquals(META_STATE, event.metaState)
50         assertEquals(REPEAT_COUNT, event.repeatCount)
51     }
52 
53     /**
54      * Write to parcel as a KeyEvent, read back as a KeyEvent
55      */
56     @Test
57     fun testParcelUnparcel() {
58         val keyEvent = createVerifiedKeyEvent()
59         val parcel = Parcel.obtain()
60         keyEvent.writeToParcel(parcel, 0 /*flags*/)
61         parcel.setDataPosition(0)
62 
63         val unparceledKeyEvent = VerifiedKeyEvent.CREATOR.createFromParcel(parcel)
64         parcel.recycle()
65 
66         compareVerifiedKeyEvents(keyEvent, unparceledKeyEvent)
67     }
68 
69     /**
70      * Write to parcel as an InputEvent, read back as an InputEvent
71      */
72     @Test
73     fun testParcelInputEvent() {
74         val keyEvent = createVerifiedKeyEvent()
75         val inputEvent: VerifiedInputEvent = keyEvent
76         val parcel = Parcel.obtain()
77         inputEvent.writeToParcel(parcel, 0 /*flags*/)
78         parcel.setDataPosition(0)
79 
80         val unparceledEvent = VerifiedInputEvent.CREATOR.createFromParcel(parcel)
81         parcel.recycle()
82 
83         assertTrue(unparceledEvent is VerifiedKeyEvent)
84         compareVerifiedKeyEvents(keyEvent, unparceledEvent as VerifiedKeyEvent)
85     }
86 
87     /**
88      * Write to parcel as a KeyEvent, read back as an InputEvent
89      */
90     @Test
91     fun testParcelKeyEvent() {
92         val keyEvent = createVerifiedKeyEvent()
93         val parcel = Parcel.obtain()
94         keyEvent.writeToParcel(parcel, 0 /*flags*/)
95         parcel.setDataPosition(0)
96 
97         val unparceledEvent = VerifiedInputEvent.CREATOR.createFromParcel(parcel)
98         parcel.recycle()
99 
100         assertTrue(unparceledEvent is VerifiedKeyEvent)
101         compareVerifiedKeyEvents(keyEvent, unparceledEvent as VerifiedKeyEvent)
102     }
103 
104     /**
105      * Write to parcel as an InputEvent, read back as a KeyEvent
106      */
107     @Test
108     fun testParcelInputToKeyEvent() {
109         val keyEvent = createVerifiedKeyEvent()
110         val inputEvent: VerifiedInputEvent = keyEvent
111         val parcel = Parcel.obtain()
112         inputEvent.writeToParcel(parcel, 0 /*flags*/)
113         parcel.setDataPosition(0)
114 
115         val unparceledEvent = VerifiedKeyEvent.CREATOR.createFromParcel(parcel)
116         parcel.recycle()
117 
118         compareVerifiedKeyEvents(keyEvent, unparceledEvent)
119     }
120 
121     @Test
122     fun testEqualsHashcode() {
123         val keyEvent1 = createVerifiedKeyEvent()
124         val keyEvent2 = createVerifiedKeyEvent()
125         compareVerifiedKeyEvents(keyEvent1, keyEvent2)
126     }
127 
128     companion object {
129         private const val DEVICE_ID = 0
130         private const val EVENT_TIME_NANOS: Long = 2000
131         private const val SOURCE = SOURCE_KEYBOARD
132         private const val DISPLAY_ID = 2
133 
134         private const val ACTION = ACTION_DOWN
135         private const val DOWN_TIME_NANOS: Long = 1000
136         private const val FLAGS = 3
137         private const val KEY_CODE = 4
138         private const val SCAN_CODE = 5
139         private const val META_STATE = 11
140         private const val REPEAT_COUNT = 22
141 
142         private fun createVerifiedKeyEvent(): VerifiedKeyEvent {
143             return VerifiedKeyEvent(DEVICE_ID, EVENT_TIME_NANOS, SOURCE, DISPLAY_ID, ACTION,
144                     DOWN_TIME_NANOS, FLAGS, KEY_CODE, SCAN_CODE, META_STATE, REPEAT_COUNT)
145         }
146 
147         private fun compareVerifiedKeyEvents(event1: VerifiedKeyEvent, event2: VerifiedKeyEvent) {
148             assertEquals(event1, event2)
149             assertEquals(event1.hashCode(), event2.hashCode())
150 
151             assertEquals(event1.deviceId, event2.deviceId)
152             assertEquals(event1.eventTimeNanos, event2.eventTimeNanos)
153             assertEquals(event1.source, event2.source)
154             assertEquals(event1.displayId, event2.displayId)
155 
156             assertEquals(event1.action, event2.action)
157             assertEquals(event1.downTimeNanos, event2.downTimeNanos)
158             assertEquals(event1.flags, event2.flags)
159             assertEquals(event1.keyCode, event2.keyCode)
160             assertEquals(event1.scanCode, event2.scanCode)
161             assertEquals(event1.metaState, event2.metaState)
162             assertEquals(event1.repeatCount, event2.repeatCount)
163         }
164     }
165 }
166