#tabbrowser-tabs {
  visibility: collapse;
}

#titlebar #TabsToolbar {
  background-color: var(--toolbar-bgcolor);
  background-image: var(--toolbar-bgimage);
  padding-top: 5px;
}

Tested on Firefox v100.0.2.

ssh-keygen -t ed25519

Write config

Create a file named config inside ~/.ssh and add the following.

Host <server-name>
 Hostname <ip>
 User <username>
 IdentityFile <path-to-private-key>

Now you can log in to your server easily with ssh <server-name> instead of having to type ssh -i <path-to-private-key> <username>@<Hostname>

Fix disconnection on idle

Client will keep sending null packets every 100 seconds to keep the connection alive. Add

ServerAliveInterval 100

to either

sudo vi /etc/ssh/ssh_config

or

vi ~/.ssh/config

Alternatively, you can do ssh -o ServerAliveInterval=100 me@remote

Reverse Port Forwading

Add these lines to /etc/ssh/sshd_config on your server

GatewayPorts clientspecified
AllowTcpForwarding yes

Then open the terminal on your local computer, paste the following and change the values suitably

ssh -o ExitOnForwardFailure=yes -v -N -R "*:$SERVER_PORT:*:$CLIENT_PORT" server_name

Flags:
R = Specifies that connections to the given TCP port or Unix socket on the remote (server) host are to be forwarded to the local side.
N = Do not execute a remote command, in simple words, do not log in to the server.
v = Verbose mode. Causes ssh to print debugging messages about its progress.

server_name is either username@ip or server name that you configured on your ~/.ssh/config
If you want to bind to only IPv4 addresses, use 0.0.0.0 instead of *

If there is frequent disconnection, follow this to fix it.

1. If a module named human has no submodules, you should put the declaration for the human in a file named human.rs
2. If a module named human does have a submodule, you should put the declarations for human in a file named human/mod.rs

Example

/*
src/lib.rs
*/
pub mod Human;

/*
src/human/mod.rs
*/
pub mod social;
pub mod action;

/*
src/human/social.rs
*/
pub fn have_fun(){
	println!("Have fun");
}

/*
src/human/action.rs
*/
pub fn walk(){
	println!("walking");
}


/*
src/main.rs
*/
use my_project_name::human;

fn main(){
	human::social::have_fun();
	human::action::walk();
}

let greeting = "Good morning";

greeting is a string literal and they are immutable. The reason why it's immutable is explained below.

In Rust, you can store part of the String and they are called String slices. For example,

let str = String::from("Hello there");

let hello = &str[0..4];
let there = &str[6..10];

hello and there are String slices. They store references to the portion of the String.

Now let's talk about why string literals are immutable. The string literals are literally slices of a string. Imagine that the value Good morning is stored on the heap(in a memory location called temp) then the greeting variable is basically temp[0..temp.len()] (can write as temp[..])

As I mentioned in the ownership chapter, if you have an immutable reference to a variable, you cannot take a mutable reference for the same.

Here is an example.

fn main(){
	let str = String::from("Hello there");
	let hello = &str[0..4];
	let there = &str[6..10];

	/*this will result in an error because `hello`
	a `there` already have an immutable reference to `str`*/
	str.clear();
}

Functions

assert!(1 == 2, "wasn't true"); //it will print wasn't true when test fails
assert_eq!(6, 6);
assert_ne!(6, 5);

Run test

cargo test

Run tests in parallel or consecutively

cargo test -- --test-threads=<numbers>

Change output capture behavior, show logs

cargo test -- --nocapture

Run single or multiple tests

cargo test <function-name|pattern>

pub fn add_one(num: i64) -> i64 {
    num + 1
}

pub fn add_two(num: i64) -> i64 {
    num + 2
}

#[cfg(test)]
mod tests {
	use super::*;
	#[test]
	fn add_one_test() {
		assert_eq!!(4, add_one(3));
	}

	#[test]
	fn add_two_test() {
		assert_eq!(6, add_two(4));
	}
}

Example

//will run only one test
cargo test add_one_test
//will run all tests starting with add_
cargo test add_

Test function that should panic

use #[should_panic] attribute

pub fn i_panic() {
    panic!("omg!");
}

#[cfg(test)]
mod test {
    use super::*;
    #[test]
    #[should_panic]
    fn should_panic() {
        i_panic();
    }
}

//The above test will pass

Ignore a test

Use #[ignore] attribute

Integration tests

Make a directory called tests at the root level of the project. Assume you have this code in the lib.rs file in the project adder

/*
|-adder/src
  |--lib.rs
*/
pub add_two(num: i64) -> i64{
	num + 2
}

tests/integration_test.rs

extern crate adder;

#[test]
fn add_two_test(){
	assert_eq!(6, adder::add_two(4));
}

We don't need to use #[cfg(test)] here. When running cargo test, it will run both unit and integration tests. You can also run only tests from a particular integration test file. In the above example, if you want to run tests from integration_test.ts file

cargo test --test integration_test.rs