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