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
|
//===----------------------------------------------------------------------===//
//
// This source file is part of the SwiftNIO open source project
//
// Copyright (c) 2017-2018 Apple Inc. and the SwiftNIO project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of SwiftNIO project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
import XCTest
@testable import NIO
class IdleStateHandlerTest : XCTestCase {
func testIdleRead() throws {
try testIdle(IdleStateHandler(readTimeout: .seconds(1)), false, { $0 == IdleStateHandler.IdleStateEvent.read })
}
func testIdleWrite() throws {
try testIdle(IdleStateHandler(writeTimeout: .seconds(1)), true, { $0 == IdleStateHandler.IdleStateEvent.write })
}
func testIdleAllWrite() throws {
try testIdle(IdleStateHandler(allTimeout: .seconds(1)), true, { $0 == IdleStateHandler.IdleStateEvent.all })
}
func testIdleAllRead() throws {
try testIdle(IdleStateHandler(allTimeout: .seconds(1)), false, { $0 == IdleStateHandler.IdleStateEvent.all })
}
private func testIdle(_ handler: IdleStateHandler, _ writeToChannel: Bool, _ assertEventFn: @escaping (IdleStateHandler.IdleStateEvent) -> Bool) throws {
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
class TestWriteHandler: ChannelInboundHandler {
typealias InboundIn = ByteBuffer
typealias OutboundOut = ByteBuffer
private var read = false
private let writeToChannel: Bool
private let assertEventFn: (IdleStateHandler.IdleStateEvent) -> Bool
init(_ writeToChannel: Bool, _ assertEventFn: @escaping (IdleStateHandler.IdleStateEvent) -> Bool) {
self.writeToChannel = writeToChannel
self.assertEventFn = assertEventFn
}
public func channelRead(context: ChannelHandlerContext, data: NIOAny) {
self.read = true
}
public func userInboundEventTriggered(context: ChannelHandlerContext, event: Any) {
if !self.writeToChannel {
XCTAssertTrue(self.read)
}
XCTAssertTrue(assertEventFn(event as! IdleStateHandler.IdleStateEvent))
context.close(promise: nil)
}
public func channelActive(context: ChannelHandlerContext) {
if writeToChannel {
var buffer = context.channel.allocator.buffer(capacity: 4)
buffer.writeStaticString("test")
context.writeAndFlush(self.wrapOutboundOut(buffer), promise: nil)
}
}
}
let serverChannel = try assertNoThrowWithValue(ServerBootstrap(group: group)
.serverChannelOption(ChannelOptions.socketOption(.so_reuseaddr), value: 1)
.childChannelInitializer { channel in
channel.pipeline.addHandler(handler).flatMap { f in
channel.pipeline.addHandler(TestWriteHandler(writeToChannel, assertEventFn))
}
}.bind(host: "127.0.0.1", port: 0).wait())
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let clientChannel = try assertNoThrowWithValue(ClientBootstrap(group: group)
.connect(to: serverChannel.localAddress!)
.wait())
if !writeToChannel {
var buffer = clientChannel.allocator.buffer(capacity: 4)
buffer.writeStaticString("test")
XCTAssertNoThrow(try clientChannel.writeAndFlush(NIOAny(buffer)).wait())
}
XCTAssertNoThrow(try clientChannel.closeFuture.wait())
}
func testPropagateInboundEvents() {
class EventHandler: ChannelInboundHandler {
typealias InboundIn = Any
var active = false
var inactive = false
var read = false
var readComplete = false
var writabilityChanged = false
var eventTriggered = false
var errorCaught = false
var registered = false
var unregistered = false
func channelActive(context: ChannelHandlerContext) {
self.active = true
}
func channelInactive(context: ChannelHandlerContext) {
self.inactive = true
}
func channelRead(context: ChannelHandlerContext, data: NIOAny) {
self.read = true
}
func channelReadComplete(context: ChannelHandlerContext) {
self.readComplete = true
}
func channelWritabilityChanged(context: ChannelHandlerContext) {
self.writabilityChanged = true
}
func userInboundEventTriggered(context: ChannelHandlerContext, event: Any) {
self.eventTriggered = true
}
func errorCaught(context: ChannelHandlerContext, error: Error) {
self.errorCaught = true
}
func channelRegistered(context: ChannelHandlerContext) {
self.registered = true
}
func channelUnregistered(context: ChannelHandlerContext) {
self.unregistered = true
}
func assertAllEventsReceived() {
XCTAssertTrue(self.active)
XCTAssertTrue(self.inactive)
XCTAssertTrue(self.read)
XCTAssertTrue(self.readComplete)
XCTAssertTrue(self.writabilityChanged)
XCTAssertTrue(self.eventTriggered)
XCTAssertTrue(self.errorCaught)
XCTAssertTrue(self.registered)
XCTAssertTrue(self.unregistered)
}
}
let eventHandler = EventHandler()
let channel = EmbeddedChannel()
XCTAssertNoThrow(try channel.pipeline.addHandler(IdleStateHandler()).wait())
XCTAssertNoThrow(try channel.pipeline.addHandler(eventHandler).wait())
channel.pipeline.fireChannelRegistered()
channel.pipeline.fireChannelActive()
channel.pipeline.fireChannelRead(NIOAny(""))
channel.pipeline.fireChannelReadComplete()
channel.pipeline.fireErrorCaught(ChannelError.alreadyClosed)
channel.pipeline.fireUserInboundEventTriggered("")
channel.pipeline.fireChannelWritabilityChanged()
channel.pipeline.fireChannelInactive()
channel.pipeline.fireChannelUnregistered()
XCTAssertTrue(try channel.finish().isClean)
eventHandler.assertAllEventsReceived()
}
}
|
