foster/denoland-rusty-v8
0
0
Fork 0
mirror of https://github.com/denoland/rusty_v8.git synced 2024-12-24 00:00:06 -05:00
Code Issues Activity

dedup inspector client/channel test implementations (#262)

Browse source
This commit is contained in:
Ryan Dahl 2020-01-29 13:11:22 -05:00 committed by GitHub
parent 3dbf414752
commit 87fdcdc131
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
1 changed files with 104 additions and 162 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

266
tests/test_api.rs
View file

@ -2261,6 +2261,97 @@ fn try_from_local() {
}
}
struct ClientCounter {
base: v8::inspector::V8InspectorClientBase,
count_run_message_loop_on_pause: usize,
count_quit_message_loop_on_pause: usize,
count_run_if_waiting_for_debugger: usize,
}
impl ClientCounter {
fn new() -> Self {
Self {
base: v8::inspector::V8InspectorClientBase::new::<Self>(),
count_run_message_loop_on_pause: 0,
count_quit_message_loop_on_pause: 0,
count_run_if_waiting_for_debugger: 0,
}
}
}
impl v8::inspector::V8InspectorClientImpl for ClientCounter {
fn base(&self) -> &v8::inspector::V8InspectorClientBase {
&self.base
}
fn base_mut(&mut self) -> &mut v8::inspector::V8InspectorClientBase {
&mut self.base
}
fn run_message_loop_on_pause(&mut self, context_group_id: i32) {
assert_eq!(context_group_id, 1);
self.count_run_message_loop_on_pause += 1;
}
fn quit_message_loop_on_pause(&mut self) {
self.count_quit_message_loop_on_pause += 1;
}
fn run_if_waiting_for_debugger(&mut self, context_group_id: i32) {
assert_eq!(context_group_id, 1);
self.count_run_message_loop_on_pause += 1;
}
}
struct ChannelCounter {
base: v8::inspector::ChannelBase,
count_send_response: usize,
count_send_notification: usize,
count_flush_protocol_notifications: usize,
}
impl ChannelCounter {
pub fn new() -> Self {
Self {
base: v8::inspector::ChannelBase::new::<Self>(),
count_send_response: 0,
count_send_notification: 0,
count_flush_protocol_notifications: 0,
}
}
}
impl v8::inspector::ChannelImpl for ChannelCounter {
fn base(&self) -> &v8::inspector::ChannelBase {
&self.base
}
fn base_mut(&mut self) -> &mut v8::inspector::ChannelBase {
&mut self.base
}
fn send_response(
&mut self,
call_id: i32,
message: v8::UniquePtr<v8::inspector::StringBuffer>,
) {
println!(
"send_response call_id {} message {}",
call_id,
message.unwrap().string()
);
self.count_send_response += 1;
}
fn send_notification(
&mut self,
message: v8::UniquePtr<v8::inspector::StringBuffer>,
) {
println!("send_notificatio message {}", message.unwrap().string());
self.count_send_notification += 1;
}
fn flush_protocol_notifications(&mut self) {
self.count_flush_protocol_notifications += 1;
}
}
#[test]
fn inspector_dispatch_protocol_message() {
let _setup_guard = setup();
@ -2272,79 +2363,18 @@ fn inspector_dispatch_protocol_message() {
use v8::inspector::*;
struct Client {
base: V8InspectorClientBase,
}
impl Client {
fn new() -> Self {
Self {
base: V8InspectorClientBase::new::<Self>(),
}
}
}
impl V8InspectorClientImpl for Client {
fn base(&self) -> &V8InspectorClientBase {
&self.base
}
fn base_mut(&mut self) -> &mut V8InspectorClientBase {
&mut self.base
}
}
struct TestChannel {
base: ChannelBase,
send_response_count: usize,
send_notification_count: usize,
flush_protocol_notifications_count: usize,
}
impl TestChannel {
pub fn new() -> Self {
Self {
base: ChannelBase::new::<Self>(),
send_response_count: 0,
send_notification_count: 0,
flush_protocol_notifications_count: 0,
}
}
}
impl ChannelImpl for TestChannel {
fn base(&self) -> &ChannelBase {
&self.base
}
fn base_mut(&mut self) -> &mut ChannelBase {
&mut self.base
}
fn send_response(
&mut self,
_call_id: i32,
_message: v8::UniquePtr<StringBuffer>,
) {
self.send_response_count += 1;
}
fn send_notification(&mut self, _message: v8::UniquePtr<StringBuffer>) {
self.send_notification_count += 1;
}
fn flush_protocol_notifications(&mut self) {
self.flush_protocol_notifications_count += 1;
}
}
let mut hs = v8::HandleScope::new(scope);
let scope = hs.enter();
let context = v8::Context::new(scope);
let mut cs = v8::ContextScope::new(scope, context);
let _scope = cs.enter();
let mut default_client = Client::new();
let mut default_client = ClientCounter::new();
let mut inspector = V8Inspector::create(&mut isolate, &mut default_client);
let name = b"";
let name_view = StringView::from(&name[..]);
inspector.context_created(context, 1, &name_view);
let mut channel = TestChannel::new();
let mut channel = ChannelCounter::new();
let state = b"{}";
let state_view = StringView::from(&state[..]);
let mut session = inspector.connect(1, &mut channel, &state_view);
@ -2354,9 +2384,9 @@ fn inspector_dispatch_protocol_message() {
let message = &message.into_bytes()[..];
let string_view = StringView::from(message);
session.dispatch_protocol_message(&string_view);
assert_eq!(channel.send_response_count, 1);
assert_eq!(channel.send_notification_count, 0);
assert_eq!(channel.flush_protocol_notifications_count, 0);
assert_eq!(channel.count_send_response, 1);
assert_eq!(channel.count_send_notification, 0);
assert_eq!(channel.count_flush_protocol_notifications, 0);
}
#[test]
@ -2370,103 +2400,15 @@ fn inspector_schedule_pause_on_next_statement() {
use v8::inspector::*;
struct Client {
base: V8InspectorClientBase,
count_run_message_loop_on_pause: usize,
count_quit_message_loop_on_pause: usize,
count_run_if_waiting_for_debugger: usize,
}
impl Client {
fn new() -> Self {
Self {
base: V8InspectorClientBase::new::<Self>(),
count_run_message_loop_on_pause: 0,
count_quit_message_loop_on_pause: 0,
count_run_if_waiting_for_debugger: 0,
}
}
}
impl V8InspectorClientImpl for Client {
fn base(&self) -> &V8InspectorClientBase {
&self.base
}
fn base_mut(&mut self) -> &mut V8InspectorClientBase {
&mut self.base
}
fn run_message_loop_on_pause(&mut self, context_group_id: i32) {
assert_eq!(context_group_id, 1);
self.count_run_message_loop_on_pause += 1;
}
fn quit_message_loop_on_pause(&mut self) {
self.count_quit_message_loop_on_pause += 1;
}
fn run_if_waiting_for_debugger(&mut self, context_group_id: i32) {
assert_eq!(context_group_id, 1);
self.count_run_message_loop_on_pause += 1;
}
}
struct TestChannel {
base: ChannelBase,
send_response_count: usize,
send_notification_count: usize,
flush_protocol_notifications_count: usize,
}
impl TestChannel {
pub fn new() -> Self {
Self {
base: ChannelBase::new::<Self>(),
send_response_count: 0,
send_notification_count: 0,
flush_protocol_notifications_count: 0,
}
}
}
impl ChannelImpl for TestChannel {
fn base(&self) -> &ChannelBase {
&self.base
}
fn base_mut(&mut self) -> &mut ChannelBase {
&mut self.base
}
fn send_response(
&mut self,
call_id: i32,
message: v8::UniquePtr<StringBuffer>,
) {
println!(
"send_response call_id {} message {}",
call_id,
message.unwrap().string()
);
self.send_response_count += 1;
}
fn send_notification(&mut self, message: v8::UniquePtr<StringBuffer>) {
println!("send_notificatio message {}", message.unwrap().string());
self.send_notification_count += 1;
}
fn flush_protocol_notifications(&mut self) {
self.flush_protocol_notifications_count += 1;
}
}
let mut hs = v8::HandleScope::new(scope);
let scope = hs.enter();
let context = v8::Context::new(scope);
let mut cs = v8::ContextScope::new(scope, context);
let scope = cs.enter();
let mut client = Client::new();
let mut client = ClientCounter::new();
let mut inspector = V8Inspector::create(&mut isolate, &mut client);
let mut channel = TestChannel::new();
let mut channel = ChannelCounter::new();
let state = b"{}";
let state_view = StringView::from(&state[..]);
let mut session = inspector.connect(1, &mut channel, &state_view);
@ -2495,9 +2437,9 @@ fn inspector_schedule_pause_on_next_statement() {
let detail = StringView::from(&detail[..]);
session.schedule_pause_on_next_statement(&reason, &detail);
assert_eq!(channel.send_response_count, 1);
assert_eq!(channel.send_notification_count, 0);
assert_eq!(channel.flush_protocol_notifications_count, 0);
assert_eq!(channel.count_send_response, 1);
assert_eq!(channel.count_send_notification, 0);
assert_eq!(channel.count_flush_protocol_notifications, 0);
assert_eq!(client.count_run_message_loop_on_pause, 0);
assert_eq!(client.count_quit_message_loop_on_pause, 0);
assert_eq!(client.count_run_if_waiting_for_debugger, 0);
@ -2505,9 +2447,9 @@ fn inspector_schedule_pause_on_next_statement() {
let r = eval(scope, context, "1+2").unwrap();
assert!(r.is_number());
assert_eq!(channel.send_response_count, 1);
assert_eq!(channel.send_notification_count, 3);
assert_eq!(channel.flush_protocol_notifications_count, 0);
assert_eq!(channel.count_send_response, 1);
assert_eq!(channel.count_send_notification, 3);
assert_eq!(channel.count_flush_protocol_notifications, 0);
assert_eq!(client.count_run_message_loop_on_pause, 1);
assert_eq!(client.count_quit_message_loop_on_pause, 0);
assert_eq!(client.count_run_if_waiting_for_debugger, 0);