Skip to content

Commit 19f298a

Browse files
illegalprimeillegalprime
committed
pass all current tests with warnings
1 parent d5864e2 commit 19f298a

File tree

10 files changed

+440
-479
lines changed

10 files changed

+440
-479
lines changed

‎examples/autobahn-client.rs‎

Lines changed: 131 additions & 141 deletions
Original file line numberDiff line numberDiff line change
@@ -2,156 +2,146 @@ extern crate websocket;
22
extern crate rustc_serialize as serialize;
33

44
use std::str::from_utf8;
5-
use websocket::client::request::Url;
6-
use websocket::{Client, Message, Sender, Receiver};
5+
use websocket::ClientBuilder;
6+
use websocket::Message;
77
use websocket::message::Type;
88
use serialize::json;
99

1010
fn main() {
11-
let addr = "ws://127.0.0.1:9001".to_string();
12-
let agent = "rust-websocket";
13-
14-
println!("Using fuzzingserver {}", addr);
15-
println!("Using agent {}", agent);
16-
17-
println!("Running test suite...");
18-
19-
let mut current_case_id = 1;
20-
let case_count = get_case_count(addr.clone());
21-
22-
while current_case_id <= case_count {
23-
let url = addr.clone() + "/runCase?case=" + &current_case_id.to_string()[..] + "&agent=" + agent;
24-
25-
let ws_uri = Url::parse(&url[..]).unwrap();
26-
let request = Client::connect(ws_uri).unwrap();
27-
let response = request.send().unwrap();
28-
match response.validate() {
29-
Ok(()) => (),
30-
Err(e) => {
31-
println!("{:?}", e);
32-
current_case_id += 1;
33-
continue;
34-
}
35-
}
36-
let (mut sender, mut receiver) = response.begin().split();
37-
38-
println!("Executing test case: {}/{}", current_case_id, case_count);
39-
40-
for message in receiver.incoming_messages() {
41-
let message: Message = match message {
42-
Ok(message) => message,
43-
Err(e) => {
44-
println!("Error: {:?}", e);
45-
let _ = sender.send_message(&Message::close());
46-
break;
47-
}
48-
};
49-
50-
match message.opcode {
51-
Type::Text => {
11+
let addr = "ws://127.0.0.1:9001".to_string();
12+
let agent = "rust-websocket";
13+
14+
println!("Using fuzzingserver {}", addr);
15+
println!("Using agent {}", agent);
16+
17+
println!("Running test suite...");
18+
19+
let mut current_case_id = 1;
20+
let case_count = get_case_count(addr.clone());
21+
22+
while current_case_id <= case_count {
23+
let case_id = current_case_id;
24+
current_case_id += 1;
25+
let url = addr.clone() + "/runCase?case=" + &case_id.to_string()[..] + "&agent=" + agent;
26+
27+
let client = ClientBuilder::new(&url).unwrap()
28+
.connect_insecure().unwrap();
29+
30+
let (mut receiver, mut sender) = client.split().unwrap();
31+
32+
println!("Executing test case: {}/{}", case_id, case_count);
33+
34+
for message in receiver.incoming_messages() {
35+
let message: Message = match message {
36+
Ok(message) => message,
37+
Err(e) => {
38+
println!("Error: {:?}", e);
39+
let _ = sender.send_message(&Message::close());
40+
break;
41+
}
42+
};
43+
44+
match message.opcode {
45+
Type::Text => {
5246
let response = Message::text(from_utf8(&*message.payload).unwrap());
53-
sender.send_message(&response).unwrap();
54-
}
55-
Type::Binary => {
56-
sender.send_message(&Message::binary(message.payload)).unwrap();
57-
}
58-
Type::Close => {
59-
let _ = sender.send_message(&Message::close());
60-
break;
61-
}
62-
Type::Ping => {
63-
sender.send_message(&Message::pong(message.payload)).unwrap();
64-
}
65-
_ => (),
66-
}
67-
}
68-
69-
current_case_id += 1;
70-
}
71-
72-
update_reports(addr.clone(), agent);
47+
sender.send_message(&response).unwrap();
48+
}
49+
Type::Binary => {
50+
sender.send_message(&Message::binary(message.payload)).unwrap();
51+
}
52+
Type::Close => {
53+
let _ = sender.send_message(&Message::close());
54+
break;
55+
}
56+
Type::Ping => {
57+
sender.send_message(&Message::pong(message.payload)).unwrap();
58+
}
59+
_ => (),
60+
}
61+
}
62+
}
63+
64+
update_reports(addr.clone(), agent);
7365
}
7466

7567
fn get_case_count(addr: String) -> usize {
76-
let url = addr + "/getCaseCount";
77-
let ws_uri = Url::parse(&url[..]).unwrap();
78-
let request = Client::connect(ws_uri).unwrap();
79-
let response = request.send().unwrap();
80-
match response.validate() {
81-
Ok(()) => (),
82-
Err(e) => {
83-
println!("{:?}", e);
84-
return 0;
85-
}
86-
}
87-
let (mut sender, mut receiver) = response.begin().split();
88-
89-
let mut count = 0;
90-
91-
for message in receiver.incoming_messages() {
92-
let message: Message = match message {
93-
Ok(message) => message,
94-
Err(e) => {
95-
println!("Error: {:?}", e);
96-
let _ = sender.send_message(&Message::close_because(1002, "".to_string()));
97-
break;
98-
}
99-
};
100-
match message.opcode {
101-
Type::Text => {
102-
count = json::decode(from_utf8(&*message.payload).unwrap()).unwrap();
103-
println!("Will run {} cases...", count);
104-
}
105-
Type::Close => {
106-
let _ = sender.send_message(&Message::close());
107-
break;
108-
}
109-
Type::Ping => {
110-
sender.send_message(&Message::pong(message.payload)).unwrap();
111-
}
112-
_ => (),
113-
}
114-
}
115-
116-
count
68+
let url = addr + "/getCaseCount";
69+
70+
let client = match ClientBuilder::new(&url).unwrap().connect_insecure() {
71+
Ok(c) => c,
72+
Err(e) => {
73+
println!("{:?}", e);
74+
return 0;
75+
},
76+
};
77+
78+
let (mut receiver, mut sender) = client.split().unwrap();
79+
80+
let mut count = 0;
81+
82+
for message in receiver.incoming_messages() {
83+
let message: Message = match message {
84+
Ok(message) => message,
85+
Err(e) => {
86+
println!("Error: {:?}", e);
87+
let _ = sender.send_message(&Message::close_because(1002, "".to_string()));
88+
break;
89+
}
90+
};
91+
match message.opcode {
92+
Type::Text => {
93+
count = json::decode(from_utf8(&*message.payload).unwrap()).unwrap();
94+
println!("Will run {} cases...", count);
95+
}
96+
Type::Close => {
97+
let _ = sender.send_message(&Message::close());
98+
break;
99+
}
100+
Type::Ping => {
101+
sender.send_message(&Message::pong(message.payload)).unwrap();
102+
}
103+
_ => (),
104+
}
105+
}
106+
107+
count
117108
}
118109

119110
fn update_reports(addr: String, agent: &str) {
120-
let url = addr + "/updateReports?agent=" + agent;
121-
let ws_uri = Url::parse(&url[..]).unwrap();
122-
let request = Client::connect(ws_uri).unwrap();
123-
let response = request.send().unwrap();
124-
match response.validate() {
125-
Ok(()) => (),
126-
Err(e) => {
127-
println!("{:?}", e);
128-
return;
129-
}
130-
}
131-
let (mut sender, mut receiver) = response.begin().split();
132-
133-
println!("Updating reports...");
134-
135-
for message in receiver.incoming_messages() {
136-
let message: Message = match message {
137-
Ok(message) => message,
138-
Err(e) => {
139-
println!("Error: {:?}", e);
140-
let _ = sender.send_message(&Message::close());
141-
return;
142-
}
143-
};
144-
match message.opcode {
145-
Type::Close => {
146-
let _ = sender.send_message(&Message::close());
147-
println!("Reports updated.");
148-
println!("Test suite finished!");
149-
return;
150-
}
151-
Type::Ping => {
152-
sender.send_message(&Message::pong(message.payload)).unwrap();
153-
}
154-
_ => (),
155-
}
156-
}
111+
let url = addr + "/updateReports?agent=" + agent;
112+
113+
let client = match ClientBuilder::new(&url).unwrap().connect_insecure() {
114+
Ok(c) => c,
115+
Err(e) => {
116+
println!("{:?}", e);
117+
return;
118+
},
119+
};
120+
121+
let (mut receiver, mut sender) = client.split().unwrap();
122+
123+
println!("Updating reports...");
124+
125+
for message in receiver.incoming_messages() {
126+
let message: Message = match message {
127+
Ok(message) => message,
128+
Err(e) => {
129+
println!("Error: {:?}", e);
130+
let _ = sender.send_message(&Message::close());
131+
return;
132+
}
133+
};
134+
match message.opcode {
135+
Type::Close => {
136+
let _ = sender.send_message(&Message::close());
137+
println!("Reports updated.");
138+
println!("Test suite finished!");
139+
return;
140+
}
141+
Type::Ping => {
142+
sender.send_message(&Message::pong(message.payload)).unwrap();
143+
}
144+
_ => (),
145+
}
146+
}
157147
}

‎examples/autobahn-server.rs‎

Lines changed: 31 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -2,48 +2,45 @@ extern crate websocket;
22

33
use std::thread;
44
use std::str::from_utf8;
5-
use websocket::{Server, Message, Sender, Receiver};
5+
use websocket::{Server, Message};
66
use websocket::message::Type;
77

88
fn main() {
9-
let addr = "127.0.0.1:9002".to_string();
9+
let server = Server::bind("127.0.0.1:9002").unwrap();
1010

11-
let server = Server::bind(&addr[..]).unwrap();
11+
for connection in server {
12+
thread::spawn(move || {
13+
let client = connection.accept().unwrap();
1214

13-
for connection in server {
14-
thread::spawn(move || {
15-
let request = connection.unwrap().read_request().unwrap();
16-
request.validate().unwrap();
17-
let response = request.accept();
18-
let (mut sender, mut receiver) = response.send().unwrap().split();
15+
let (mut receiver, mut sender) = client.split().unwrap();
1916

20-
for message in receiver.incoming_messages() {
21-
let message: Message = match message {
22-
Ok(message) => message,
23-
Err(e) => {
24-
println!("{:?}", e);
25-
let _ = sender.send_message(&Message::close());
26-
return;
27-
}
28-
};
17+
for message in receiver.incoming_messages() {
18+
let message: Message = match message {
19+
Ok(message) => message,
20+
Err(e) => {
21+
println!("{:?}", e);
22+
let _ = sender.send_message(&Message::close());
23+
return;
24+
}
25+
};
2926

30-
match message.opcode {
31-
Type::Text => {
27+
match message.opcode {
28+
Type::Text => {
3229
let response = Message::text(from_utf8(&*message.payload).unwrap());
3330
sender.send_message(&response).unwrap()
3431
},
35-
Type::Binary => sender.send_message(&Message::binary(message.payload)).unwrap(),
36-
Type::Close => {
37-
let _ = sender.send_message(&Message::close());
38-
return;
39-
}
40-
Type::Ping => {
41-
let message = Message::pong(message.payload);
42-
sender.send_message(&message).unwrap();
43-
}
44-
_ => (),
45-
}
46-
}
47-
});
48-
}
32+
Type::Binary => sender.send_message(&Message::binary(message.payload)).unwrap(),
33+
Type::Close => {
34+
let _ = sender.send_message(&Message::close());
35+
return;
36+
}
37+
Type::Ping => {
38+
let message = Message::pong(message.payload);
39+
sender.send_message(&message).unwrap();
40+
}
41+
_ => (),
42+
}
43+
}
44+
});
45+
}
4946
}

0 commit comments

Comments
 (0)