izackp/mosh
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

clang-format Mosh

Browse Source 
Run clang-format over the Mosh source tree. This is a large change and
has been factored into its own commit for auditability. Reproduce it
with

    find . -name \*.cc -or -name \*.h | while read f; do clang-format -i --style=file $f; done
This commit is contained in:
Benjamin Barenblat
2023-08-07 21:53:48 -04:00
committed by Alex Chernyakhovsky
parent 0b15dc94fa
commit 3acaa1c4d3
77 changed files with 4838 additions and 4848 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/tests/base64.cc
+27 -26
View File
@@ -38,54 +38,55 @@
the Mosh project. */
#include <cstdint>
#include <cstring>
#include <cstdlib>
#include <cstring>
#include "src/crypto/base64.h"
#include "base64_vector.h"
#include "src/crypto/base64.h"
#include "src/crypto/crypto.h"
#include "src/crypto/prng.h"
#include "src/util/fatal_assert.h"
// #include "test_utils.h"
#define KEY_LEN 16
#define KEY_LEN 16
#define NONCE_LEN 12
#define TAG_LEN 16
#define TAG_LEN 16
bool verbose = false;
static void test_base64( void ) {
static void test_base64( void )
{
/* run through a test vector */
char encoded[25];
uint8_t decoded[16];
size_t b64_len = 24;
size_t raw_len = 16;
for ( base64_test_row *row = static_base64_vector; *row->native != '\0'; row++ ) {
memset(encoded, '\0', sizeof encoded);
memset(decoded, '\0', sizeof decoded);
for ( base64_test_row* row = static_base64_vector; *row->native != '\0'; row++ ) {
memset( encoded, '\0', sizeof encoded );
memset( decoded, '\0', sizeof decoded );
base64_encode(static_cast<const uint8_t *>(row->native), raw_len, encoded, b64_len);
base64_encode( static_cast<const uint8_t*>( row->native ), raw_len, encoded, b64_len );
fatal_assert( b64_len == 24 );
fatal_assert( !memcmp(row->encoded, encoded, sizeof encoded));
fatal_assert( !memcmp( row->encoded, encoded, sizeof encoded ) );
fatal_assert( base64_decode(row->encoded, b64_len, decoded, &raw_len ));
fatal_assert( base64_decode( row->encoded, b64_len, decoded, &raw_len ) );
fatal_assert( raw_len == 16 );
fatal_assert( !memcmp(row->native, decoded, sizeof decoded));
fatal_assert( !memcmp( row->native, decoded, sizeof decoded ) );
}
if ( verbose ) {
printf( "validation PASSED\n" );
}
/* try 0..255 in the last byte; make sure the final two characters are output properly */
uint8_t source[16];
memset(source, '\0', sizeof source);
memset( source, '\0', sizeof source );
for ( int i = 0; i < 256; i++ ) {
source[15] = i;
base64_encode(source, raw_len, encoded, b64_len);
base64_encode( source, raw_len, encoded, b64_len );
fatal_assert( b64_len == 24 );
fatal_assert( base64_decode(encoded, b64_len, decoded, &raw_len ));
fatal_assert( base64_decode( encoded, b64_len, decoded, &raw_len ) );
fatal_assert( raw_len == 16 );
fatal_assert( !memcmp(source, decoded, sizeof decoded));
fatal_assert( !memcmp( source, decoded, sizeof decoded ) );
}
if ( verbose ) {
printf( "last-byte PASSED\n" );
@@ -93,17 +94,17 @@ static void test_base64( void ) {
/* randomly try keys */
PRNG prng;
for ( int i = 0; i < ( 1<<17 ); i++ ) {
Base64Key key1(prng);
Base64Key key2(key1.printable_key());
fatal_assert( key1.printable_key() == key2.printable_key() && !memcmp(key1.data(), key2.data(), 16 ));
for ( int i = 0; i < ( 1 << 17 ); i++ ) {
Base64Key key1( prng );
Base64Key key2( key1.printable_key() );
fatal_assert( key1.printable_key() == key2.printable_key() && !memcmp( key1.data(), key2.data(), 16 ) );
}
if ( verbose ) {
printf( "random PASSED\n" );
}
/* test bad keys */
const char *bad_keys[] = {
const char* bad_keys[] = {
"",
"AAAAAAAAAAAAAAAAAAAAAA",
"AAAAAAAAAAAAAAAAAAAAAA=",
@@ -119,25 +120,25 @@ static void test_base64( void ) {
"AAAAAAAAAA==",
NULL,
};
for ( const char **key = bad_keys; *key != NULL; key++ ) {
for ( const char** key = bad_keys; *key != NULL; key++ ) {
b64_len = 24;
raw_len = 16;
fatal_assert( !base64_decode(*key, b64_len, decoded, &raw_len ));
fatal_assert( !base64_decode( *key, b64_len, decoded, &raw_len ) );
}
if ( verbose ) {
printf( "bad-keys PASSED\n" );
}
}
int main( int argc, char *argv[] )
int main( int argc, char* argv[] )
{
if ( argc >= 2 && strcmp( argv[ 1 ], "-v" ) == 0 ) {
if ( argc >= 2 && strcmp( argv[1], "-v" ) == 0 ) {
verbose = true;
}
try {
test_base64();
} catch ( const std::exception &e ) {
} catch ( const std::exception& e ) {
fprintf( stderr, "Error: %s\r\n", e.what() );
return 1;
}