content stringlengths 12 12.8k | id int64 0 359 |
|---|---|
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 =... | 300 |
fn a_table_should_read_what_was_put() {
let mut table = HashMapOfTreeMap::new();
table.write(0, &[Row { k: 0, v: 1 }]);
let mut vs = [Value::default(); 1];
table.read (1, &[0], &mut vs);
assert_eq!(vs, [Value { v: 1, t: 1 }]);
} | 301 |
pub fn test_rvc_pageend() {
// The last instruction of a executable memory page is an RVC instruction.
let buffer = fs::read("tests/programs/rvc_pageend").unwrap().into();
let core_machine =
DefaultCoreMachine::<u64, SparseMemory<u64>>::new(ISA_IMC, VERSION0, u64::max_value());
let mut machine =... | 302 |
fn main() {
// Variables can be type annotated.
let i: i32 = 10;
println!("Hello, world!, {}", i);
} | 303 |
async fn main() -> std::io::Result<()> {
// Set keep-alive to 75 seconds
let _one = HttpServer::new(app).keep_alive(Duration::from_secs(75));
// Use OS's keep-alive (usually quite long)
let _two = HttpServer::new(app).keep_alive(KeepAlive::Os);
// Disable keep-alive
let _three = HttpServer::ne... | 304 |
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'));
} | 305 |
pub fn channel_take_raw(target: CAddr) -> u64 {
let result = channel_take_nonpayload(target);
match result {
ChannelMessage::Raw(v) => return v,
_ => panic!(),
};
} | 306 |
async fn retrieve_pairs() {
let exchange = init().await;
let pairs = exchange.refresh_market_info().await.unwrap();
println!("{:?}", pairs);
} | 307 |
fn hard_fault(ef: &ExceptionFrame) -> ! {
panic!("Hardfault... : {:#?}", ef);
} | 308 |
fn main() {
let num = input("Ingrese un número: ")
.unwrap()
.parse::<i32>()
.expect("Expected a number");
if num % 2 == 0 {
println!("`{}` es un número par.", num);
} else {
println!("`{}` es un número impar", num);
}
} | 309 |
fn main() {
// Resolve Directories
let root = env::current_dir()
.unwrap()
.join("..")
.canonicalize()
.unwrap();
let i_path = root.join("data/input").canonicalize().unwrap();
let o_path = root.join("data/rs").canonicalize().unwrap();
// File Names
let mut names = fs::read_dir(i_path)
.unwrap()
.map... | 310 |
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())
} | 311 |
fn get_default_database_paths() -> Vec<PathBuf> {
get_platform_dependent_data_dirs()
.into_iter()
.map(|dir| dir.join("grafen").join(DEFAULT_DBNAME))
.collect()
} | 312 |
fn into_rdf(body: &[u8], content_type: &str) -> Result<Graph, Berr> {
fn parse<P>(p: P) -> Result<Graph, Berr>
where
P: TriplesParser,
<P as TriplesParser>::Error: 'static,
{
p.into_iter(|t| -> Result<_, Berr> { Ok(triple(t)?) })
.collect::<Result<Vec<om::Triple>, Berr>>(... | 313 |
fn main() -> ! {
let p = stm32::Peripherals::take().unwrap();
let gpio_a = p.GPIOA.split();
let btn_a = gpio_a.pa4.into_pull_up_input();
let btn_b = gpio_a.pa10.into_pull_up_input();
let gpio_b = p.GPIOB.split();
let gpio_c = p.GPIOC.split();
let mut r = gpio_b.pb4.into_push_pull_output();
... | 314 |
fn assert_memory_store_empty_bytes<M: Memory>(memory: &mut M) {
assert!(memory.store_byte(0, 0, 42).is_ok());
assert!(memory.store_bytes(0, &[]).is_ok());
} | 315 |
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
(
(
)
)
} | 316 |
fn assert_memory_load_bytes_all<R: Rng>(
rng: &mut R,
max_memory: usize,
buf_size: usize,
addr: u64,
) {
assert_memory_load_bytes(
rng,
&mut SparseMemory::<u64>::new_with_memory(max_memory),
buf_size,
addr,
);
assert_memory_load_bytes(
rng,
&mu... | 317 |
fn read_dir<P: AsRef<Path>>(path: P, recursive: bool) -> io::Result<Vec<DirEntry>> {
let path = path.as_ref();
let mut entries = Vec::new();
for entry in fs::read_dir(path)? {
let entry = entry?;
let path = entry.path().to_str().unwrap().to_string();
let children = if recursive && en... | 318 |
async fn order_book() {
let exchange = init().await;
let req = OrderBookRequest {
market_pair: "eth_btc".to_string(),
};
let resp = exchange.order_book(&req).await.unwrap();
println!("{:?}", resp);
} | 319 |
fn parse_instruction(line: &str) -> Instruction {
let pieces: Vec<&str> = line.split_whitespace().collect();
let register = String::from(pieces[0]);
let increase = match pieces[1] {
"inc" => true,
"dec" => false,
_ => panic!("Expected 'inc' or 'dec'."),
};
let value ... | 320 |
fn curiosity() -> Curiosity {
Curiosity::create(
[
"SELECT DISTINCT ?s WHERE { GRAPH ?g { ?s ?p ?o } }",
"SELECT DISTINCT ?p WHERE { GRAPH ?g { ?s ?p ?o } }",
"SELECT DISTINCT ?o WHERE { GRAPH ?g { ?s ?p ?o } }",
"SELECT DISTINCT ?g WHERE { GRAPH ?g { ?s ?p ?o... | 321 |
pub async fn get_semaphored_connection<'a>() -> SemaphoredDbConnection<'a> {
let _semaphore_permit = semaphore().acquire().await.unwrap();
let connection = establish_connection();
SemaphoredDbConnection {
_semaphore_permit,
connection,
}
} | 322 |
fn die(err: impl Error) -> ! {
println!("{}", err);
std::process::exit(1);
} | 323 |
fn find_common_id() -> Option<String> {
let input = fs::File::open("input.txt")
.expect("Something went wrong reading the file");
let reader = io::BufReader::new(input);
let mut box_ids: Vec<String> = reader.lines().map(|l| l.unwrap()).collect();
box_ids.sort();
for i in 0..box_ids.len() {
... | 324 |
fn help() {
cargo_fuzz().arg("help").assert().success();
} | 325 |
pub fn solve2(input: &str) -> Option<Box<usize>> {
let sum_of_counts = input
.trim_end()
.split("\n\n")
.map(|group| {
let answers_per_person = group
.split_ascii_whitespace()
.map(|person| person.chars().collect::<HashSet<_>>())
.collect::<Vec<_>>();
answers_per_perso... | 326 |
fn a_table_should_read_0_for_any_key() {
let mut table = HashMapOfTreeMap::new();
let mut vs = [Value::default(); 1];
table.read (0, &[0], &mut vs);
match vs {
[Value { v: 0, t: 0}] => (),
_ => assert!(false)
}
} | 327 |
pub fn acrn_create_dir(path: &str, recursive: bool) -> Result<(), String> {
if recursive {
fs::create_dir_all(path).map_err(|e| e.to_string())
} else {
fs::create_dir(path).map_err(|e| e.to_string())
}
} | 328 |
pub fn quick_sort<T: PartialOrd + Debug>(v: &mut [T]) {
if v.len() <= 1 {
return;
}
let p = pivot(v);
println!("{:?}", v);
let (a, b) = v.split_at_mut(p);
quick_sort(a);
quick_sort(&mut b[1..]);
} | 329 |
fn main() {
println!("Run via `cargo run-wasm --example visualiser_for_wasm`");
} | 330 |
fn main() -> Result<(), std::io::Error> {
let mut token = std::ptr::null_mut();
let r = unsafe {OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &mut token) };
if r == 0 {
return Err(std::io::Error::last_os_error());
}
set_privilege(token, SE_RESTORE_NAME)?;
set_privilege(... | 331 |
fn process_instructions(instructions: &Vec<Instruction>) -> (HashMap<&str, i32>, i32) {
let mut registers: HashMap<&str, i32> = HashMap::new();
let mut max = 0;
for instruction in instructions {
let current = *registers.entry(&instruction.condition.register).or_insert(0);
let condition_sat... | 332 |
pub fn map_raw_page_free(vaddr: usize, untyped: CAddr, toplevel_table: CAddr, page: CAddr) {
system_call(SystemCall::MapRawPageFree {
untyped: untyped,
toplevel_table: toplevel_table,
request: (vaddr, page),
});
} | 333 |
fn run_with_coverage() {
let target = "with_coverage";
let project = project("run_with_coverage")
.with_fuzz()
.fuzz_target(
target,
r#"
#![no_main]
use libfuzzer_sys::fuzz_target;
fuzz_target!(|data: &[u8]| {
... | 334 |
fn
test_mismatched_types
(
)
-
>
Result
<
(
)
>
{
fn
is_invalid_column_type
(
err
:
Error
)
-
>
bool
{
matches
!
(
err
Error
:
:
InvalidColumnType
(
.
.
)
)
}
let
db
=
checked_memory_handle
(
)
?
;
db
.
execute
(
"
INSERT
INTO
foo
(
b
t
i
f
)
VALUES
(
X
'
0102
'
'
text
'
1
1
.
5
)
"
[
]
)
?
;
let
mut
stmt
=
db
.
prepar... | 335 |
fn pool() -> &'static Pool<ConnectionManager<PgConnection>> {
POOL.get_or_init(|| {
dotenv().ok();
let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
let manager = ConnectionManager::<PgConnection>::new(database_url);
Pool::builder()
.max_s... | 336 |
fn build_author_map(
repo: &Repository,
reviewers: &Reviewers,
mailmap: &Mailmap,
from: &str,
to: &str,
) -> Result<AuthorMap, Box<dyn std::error::Error>> {
match build_author_map_(repo, reviewers, mailmap, from, to) {
Ok(o) => Ok(o),
Err(err) => Err(ErrorContext(
for... | 337 |
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))... | 338 |
fn main() {
input! {
n:usize,
}
let n = n * 108 / 100;
if n < 206 {
println!("Yay!");
} else if n == 206 {
println!("so-so");
} else {
println!(":(");
}
} | 339 |
fn main() {
env_logger::init().unwrap_or_else(
|err|
panic!("unable to initiate env logger: {}", err)
);
match core::start() {
Ok(()) => info!("game exiting"),
Err(err) => error!("core start error: {}", err),
}
} | 340 |
extern "C" fn gatt_svr_chr_access_device_info(
_conn_handle: u16,
_attr_handle: u16,
ctxt: *mut ble_gatt_access_ctxt,
_arg: *mut ::core::ffi::c_void,
) -> i32 {
let uuid: u16 = unsafe { ble_uuid_u16((*(*ctxt).__bindgen_anon_1.chr).uuid) };
if uuid == GATT_MODEL_NUMBER_UUID {
let rc: i32... | 341 |
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
(
(
)
)
} | 342 |
pub fn current_time() -> DateTime<Utc> {
Utc::now().round_subsecs(0)
} | 343 |
pub fn test_wxorx_crash_64() {
let buffer = fs::read("tests/programs/wxorx_crash_64").unwrap().into();
let result = run::<u64, SparseMemory<u64>>(&buffer, &vec!["wxorx_crash_64".into()]);
assert_eq!(result.err(), Some(Error::MemOutOfBound));
} | 344 |
fn santa(instruction: &String) -> i32 {
// if '(' up else if ')' down
let mut floor: i32 = 0;
for paren in instruction.chars() {
println!("{}", paren);
match paren {
'(' => floor += 1,
')' => floor -= 1,
_ => panic!(),
}
}
floor
} | 345 |
fn copy_test() {
{
/*
struct Label {
number: u32,
}
fn print(l: Label) {
println!("STAMP: {}", l.number);
}
let l = Label { number: 3 };
print(l);
println!("My label number is: {}", l.number); // error
*/
#[der... | 346 |
fn build_one() {
let project = project("build_one").with_fuzz().build();
// Create some targets.
project
.cargo_fuzz()
.arg("add")
.arg("build_one_a")
.assert()
.success();
project
.cargo_fuzz()
.arg("add")
.arg("build_one_b")
.ass... | 347 |
pub fn debug_format(input: String) -> String {
if input.len() <= 20 {
return input;
}
input
.chars()
.take(8)
.chain("...".chars())
.chain(input.chars().skip(input.len() - 8))
.collect()
} | 348 |
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... | 349 |
pub fn parse(buf_reader: &mut dyn BufRead, strict: bool) -> Result<Cue, CueError> {
let verbose = env::var_os("RCUE_LOG").map(|s| s == "1").unwrap_or(false);
macro_rules! fail_if_strict {
($line_no:ident, $line:ident, $reason:expr) => {
if strict {
if verbose {
... | 350 |
fn read_num(cursor: &mut Cursor<Vec<u8>>) -> Result<u32, Box<std::error::Error>> {
let mut v: Vec<u8> = vec![];
let mut c: [u8; 1] = [0];
// consume whitespace
loop {
cursor.read(&mut c)?;
match &c {
b" " | b"\t" | b"\n" => { },
_ => { cursor.s... | 351 |
pub fn threaded_quick_sort<T: 'static + PartialOrd + Debug + Send>(v: &mut [T]) {
if v.len() <= 1 {
return;
}
let p = pivot(v);
println!("{:?}", v);
let (a, b) = v.split_at_mut(p);
let raw_a = a as *mut [T];
let raw_s = RawSend(raw_a);
unsafe {
let handle = std::thread::s... | 352 |
pub fn parse_opts() -> Result<CliStatus, Error> {
let opt = Opt::from_args();
log::debug!("Cli opts are: {:?}", opt);
match opt.cmd {
Command::Generate => {
generate_empty_config().context("Failed to generate config")?;
log::info!("config.yml generated");
Ok(CliS... | 353 |
fn add_twice() {
let project = project("add").with_fuzz().build();
project
.cargo_fuzz()
.arg("add")
.arg("new_fuzz_target")
.assert()
.success();
assert!(project.fuzz_target_path("new_fuzz_target").is_file());
project
.cargo_fuzz()
.arg("add")
... | 354 |
fn reference_test() {
use std::collections::HashMap;
type Table = HashMap<String, Vec<String>>;
let mut table = Table::new();
table.insert(
"Gesualdo".to_string(),
vec![
"many madrigals".to_string(),
"Tenebrae Responsoria".to_string(),
],
);
table.... | 355 |
async fn main() {
tracing_subscriber::registry()
.with(
tracing_subscriber::EnvFilter::try_from_default_env().unwrap_or_else(|_| {
// axum logs rejections from built-in extractors with the `axum::rejection`
// target, at `TRACE` level. `axum::rejection=trace` enab... | 356 |
pub fn debug_test_succeed() {
system_call(SystemCall::DebugTestSucceed);
loop {}
} | 357 |
pub fn star1(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 (&sleepiest_guard_id, sleepiest_guard_days) = guard_map.iter()
... | 358 |
pub fn pivot<T: PartialOrd>(v: &mut [T]) -> usize {
let mut p = rand::read(v.len());
v.swap(p, 0);
p = 0;
for i in 1..v.len() {
if v[i] < v[p] {
// move our pivot forward 1, and put this element before it
v.swap(p+1, i);
v.swap(p, p+1);
p += 1
... | 359 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.