1471

Committed 26 May 2024 04:32AM UTC coverage: 84.435% (-0.004%) from 84.439%

Build # 1471

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #446 from moonbitlang/hongbo/immut_hashmap

int overflow test and use hex notation

Run Details

3 of 11 new or added lines in 1 file covered. (27.27%)

2 existing lines in 1 file now uncovered.

2989 of 3540 relevant lines covered (84.44%)

2165.59 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

46.15

/strconv/UInt64.mbt

// Copyright 2024 International Digital Economy Academy
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

/// Pretend we have UInt64
priv type UInt64 Int64 derive(Eq)

fn new_UInt64_Int(value : Int) -> UInt64 {
  UInt64(value.to_int64())
}

fn UInt64::compare(self : UInt64, b : UInt64) -> Int {
  if self.0 >= 0L && b.0 >= 0L || self.0 < 0L && b.0 < 0L {
    self.0.compare(b.0)
  } else if self.0 < 0L { // b.0 >= 0
    1
  } else { // self.0 >= 0 && b.0 < 0
    -1
  }
}

fn op_add(self : UInt64, b : UInt64) -> UInt64 {
  UInt64(self.0 + b.0)
}

fn op_sub(self : UInt64, b : UInt64) -> UInt64 {
  UInt64(self.0 - b.0)
}

fn op_mul(self : UInt64, b : UInt64) -> UInt64 {
  UInt64(self.0 * b.0)
}

// fn op_div(self : UInt64, b : UInt64) -> UInt64 {
//   UInt64(self.0 / b.0)
// }

fn op_neg(self : UInt64) -> UInt64 {
  UInt64(-self.0)
}

fn lnot(self : UInt64) -> UInt64 {
  UInt64(self.0.lnot())
}

fn land(self : UInt64, b : UInt64) -> UInt64 {
  UInt64(self.0.land(b.0))
}

fn lor(self : UInt64, b : UInt64) -> UInt64 {
  UInt64(self.0.lor(b.0))
}

fn lxor(self : UInt64, b : UInt64) -> UInt64 {
  UInt64(self.0.lxor(b.0))
}

fn lsr(self : UInt64, b : Int) -> UInt64 {
  UInt64(self.0.lsr(b))
}

fn lsl(self : UInt64, b : Int) -> UInt64 {
  UInt64(self.0.lsl(b))
}

fn to_int64(self : UInt64) -> Int64 {
  self.0
}

fn to_double(self : UInt64) -> Double {
  if self.0 >= 0L {
    self.0.to_double()
  } else {
    Int64::max_value().to_double() + (self.0 - Int64::min_value()).to_double() +
    1.0
  }
}

/// Returns None if the multiplication might overflow (there are some false-negative corner cases).
/// Otherwise, returns Some(m), where m = self * b.
fn checked_mul(self : UInt64, b : UInt64) -> Option[UInt64] {
  if self.0 == 0L || b.0 == 0L {
    return Some(UInt64(0L))
  }
  if self.0 == 1L {
    return Some(b)
  }
  if b.0 == 1L {
    return Some(self)
  }
  if b.0 < 0L || self.0 < 0L {
    return None
  }
  let r : UInt64 = UInt64(Int64::max_value() / b.0)
  let q : UInt64 = UInt64(1L / b.0)
  if r + r + q < self {
    return None
  }
  Some(self * b)
}

test "op_lt" {
  @assertion.assert_true(new_UInt64_Int(1) < new_UInt64_Int(2))?
  @assertion.assert_true(UInt64::UInt64(-1L) > UInt64(2L))?
}

1	// Copyright 2024 International Digital Economy Academy
2	//
3	// Licensed under the Apache License, Version 2.0 (the "License");
4	// you may not use this file except in compliance with the License.
5	// You may obtain a copy of the License at
6	//
7	// http://www.apache.org/licenses/LICENSE-2.0
8	//
9	// Unless required by applicable law or agreed to in writing, software
10	// distributed under the License is distributed on an "AS IS" BASIS,
11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	// See the License for the specific language governing permissions and
13	// limitations under the License.
14
15	/// Pretend we have UInt64
16	priv type UInt64 Int64 derive(Eq)
17
18	fn new_UInt64_Int(value : Int) -> UInt64 {
19	UInt64(value.to_int64())	1,228✔
20	}
21
22	fn UInt64::compare(self : UInt64, b : UInt64) -> Int {
23	if self.0 >= 0L && b.0 >= 0L \|\| self.0 < 0L && b.0 < 0L {	200✔
24	self.0.compare(b.0)	196✔
25	} else if self.0 < 0L { // b.0 >= 0	4✔
26	1	4✔
27	} else { // self.0 >= 0 && b.0 < 0
28	-1	×
29	}
30	}
31
32	fn op_add(self : UInt64, b : UInt64) -> UInt64 {
33	UInt64(self.0 + b.0)	549✔
34	}
35
36	fn op_sub(self : UInt64, b : UInt64) -> UInt64 {
NEW 37	UInt64(self.0 - b.0)	×
38	}
39
40	fn op_mul(self : UInt64, b : UInt64) -> UInt64 {
41	UInt64(self.0 * b.0)	549✔
42	}
43
44	// fn op_div(self : UInt64, b : UInt64) -> UInt64 {
45	// UInt64(self.0 / b.0)
46	// }
47
48	fn op_neg(self : UInt64) -> UInt64 {
NEW 49	UInt64(-self.0)	×
50	}
51
52	fn lnot(self : UInt64) -> UInt64 {
NEW 53	UInt64(self.0.lnot())	×
54	}
55
56	fn land(self : UInt64, b : UInt64) -> UInt64 {
NEW 57	UInt64(self.0.land(b.0))	×
58	}
59
60	fn lor(self : UInt64, b : UInt64) -> UInt64 {
NEW 61	UInt64(self.0.lor(b.0))	×
62	}
63
64	fn lxor(self : UInt64, b : UInt64) -> UInt64 {
NEW 65	UInt64(self.0.lxor(b.0))	×
66	}
67
68	fn lsr(self : UInt64, b : Int) -> UInt64 {
NEW 69	UInt64(self.0.lsr(b))	×
70	}
71
72	fn lsl(self : UInt64, b : Int) -> UInt64 {
73	UInt64(self.0.lsl(b))	2✔
74	}
75
76	fn to_int64(self : UInt64) -> Int64 {
77	self.0	×
78	}
79
80	fn to_double(self : UInt64) -> Double {
81	if self.0 >= 0L {	64✔
82	self.0.to_double()	64✔
83	} else {
84	Int64::max_value().to_double() + (self.0 - Int64::min_value()).to_double() +	×
85	1.0
86	}
87	}
88
89	/// Returns None if the multiplication might overflow (there are some false-negative corner cases).
90	/// Otherwise, returns Some(m), where m = self * b.
91	fn checked_mul(self : UInt64, b : UInt64) -> Option[UInt64] {
92	if self.0 == 0L \|\| b.0 == 0L {	2✔
NEW 93	return Some(UInt64(0L))	×
94	}
95	if self.0 == 1L {
96	return Some(b)	2✔
97	}
98	if b.0 == 1L {
99	return Some(self)	×
100	}
101	if b.0 < 0L \|\| self.0 < 0L {
102	return None	×
103	}
104	let r : UInt64 = UInt64(Int64::max_value() / b.0)
105	let q : UInt64 = UInt64(1L / b.0)
106	if r + r + q < self {
107	return None	×
108	}
109	Some(self * b)
110	}
111
112	test "op_lt" {
113	@assertion.assert_true(new_UInt64_Int(1) < new_UInt64_Int(2))?
114	@assertion.assert_true(UInt64::UInt64(-1L) > UInt64(2L))?
115	}

moonbitlang / core / 1471

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous