mirror of
https://github.com/facebook/sapling.git
synced 2024-10-07 07:17:55 +03:00
fc8c0d61a1
Summary: This allows us to use fastmanifest as a directory to drop in the python module. Test Plan: compiles, passes existing tests. Reviewers: lcharignon Reviewed By: lcharignon Subscribers: mitrandir, mjpieters Differential Revision: https://phabricator.intern.facebook.com/D3351021 Signature: t1:3351021:1464284417:6cbcde514ab1fd7b5caa6c83cb5577f3502dbc58
374 lines
10 KiB
C
374 lines
10 KiB
C
// Copyright 2016-present Facebook. All Rights Reserved.
|
|
//
|
|
// tree_diff_test.c: tests to verify tree_diff
|
|
//
|
|
// no-check-code
|
|
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "node.h"
|
|
#include "tree.h"
|
|
#include "tests.h"
|
|
|
|
typedef struct {
|
|
const char *path;
|
|
const size_t path_sz;
|
|
const bool left_present;
|
|
uint32_t left_checksum_seed;
|
|
const uint8_t left_flags;
|
|
const bool right_present;
|
|
uint32_t right_checksum_seed;
|
|
const uint8_t right_flags;
|
|
} diff_expectation_t;
|
|
|
|
typedef struct {
|
|
diff_expectation_t *expectations;
|
|
size_t expectations_idx;
|
|
size_t expectations_sz;
|
|
} diff_expectations_t;
|
|
|
|
static void expectations_matcher(
|
|
const char *path,
|
|
const size_t path_sz,
|
|
const bool left_present,
|
|
const uint8_t *left_checksum,
|
|
const uint8_t left_checksum_sz,
|
|
const uint8_t left_flags,
|
|
const bool right_present,
|
|
const uint8_t *right_checksum,
|
|
const uint8_t right_checksum_sz,
|
|
const uint8_t right_flags,
|
|
void *context) {
|
|
uint8_t buffer[CHECKSUM_BYTES];
|
|
|
|
diff_expectations_t *expectations = (diff_expectations_t *) context;
|
|
ASSERT(expectations->expectations_idx < expectations->expectations_sz);
|
|
diff_expectation_t *expectation = &expectations->expectations[
|
|
expectations->expectations_idx];
|
|
|
|
ASSERT(expectation->path_sz == path_sz);
|
|
ASSERT(memcmp(expectation->path, path, path_sz) == 0);
|
|
ASSERT(expectation->left_present == left_present);
|
|
if (left_present) {
|
|
ASSERT(SHA1_BYTES == left_checksum_sz);
|
|
ASSERT(memcmp(int2sha1hash(expectation->left_checksum_seed, buffer),
|
|
left_checksum, left_checksum_sz) == 0);
|
|
ASSERT(expectation->left_flags == left_flags);
|
|
}
|
|
ASSERT(expectation->right_present == right_present);
|
|
if (right_present) {
|
|
ASSERT(SHA1_BYTES == right_checksum_sz);
|
|
ASSERT(memcmp(int2sha1hash(expectation->right_checksum_seed, buffer),
|
|
right_checksum, right_checksum_sz) == 0);
|
|
ASSERT(expectation->right_flags == right_flags);
|
|
}
|
|
|
|
expectations->expectations_idx++;
|
|
}
|
|
|
|
static void diff_empty_trees() {
|
|
tree_t *left = alloc_tree();
|
|
tree_t *right = alloc_tree();
|
|
|
|
diff_expectation_t expectation_array[] =
|
|
{
|
|
};
|
|
diff_expectations_t expectations = {
|
|
expectation_array,
|
|
0, sizeof(expectation_array) / sizeof(diff_expectation_t)
|
|
};
|
|
|
|
ASSERT(diff_trees(left, right, false, expectations_matcher, &expectations) ==
|
|
DIFF_OK);
|
|
ASSERT(expectations.expectations_idx == expectations.expectations_sz);
|
|
|
|
ASSERT(diff_trees(left, right, true, expectations_matcher, &expectations) ==
|
|
DIFF_OK);
|
|
ASSERT(expectations.expectations_idx == expectations.expectations_sz);
|
|
}
|
|
|
|
/**
|
|
* Diff two identical trees.
|
|
*/
|
|
static void diff_identical_trees() {
|
|
tree_t *left = alloc_tree();
|
|
tree_t *right = alloc_tree();
|
|
|
|
add_to_tree_t toadd[] = {
|
|
{STRPLUSLEN("abc"), 12345, 5},
|
|
{STRPLUSLEN("ab/cdef/ghi"), 44252, 22},
|
|
{STRPLUSLEN("ab/cdef/g/hi"), 112123, 64},
|
|
{STRPLUSLEN("ab/cdef/g/hij"), 54654, 58},
|
|
{STRPLUSLEN("ab/cdef/gh/ijk"), 45645105, 65},
|
|
{STRPLUSLEN("ab/cdef/gh/i"), 5464154, 4},
|
|
};
|
|
|
|
add_to_tree(left, toadd, sizeof(toadd) / sizeof(add_to_tree_t));
|
|
add_to_tree(right, toadd, sizeof(toadd) / sizeof(add_to_tree_t));
|
|
|
|
diff_expectation_t normal_expectation_array[] =
|
|
{
|
|
};
|
|
diff_expectations_t normal_expectations = {
|
|
normal_expectation_array,
|
|
0, sizeof(normal_expectation_array) / sizeof(diff_expectation_t)
|
|
};
|
|
|
|
ASSERT(diff_trees(
|
|
left, right,
|
|
false,
|
|
expectations_matcher, &normal_expectations) == DIFF_OK);
|
|
ASSERT(normal_expectations.expectations_idx ==
|
|
normal_expectations.expectations_sz);
|
|
|
|
diff_expectation_t include_all_expectation_array[] = {
|
|
{
|
|
STRPLUSLEN("ab/cdef/g/hi"),
|
|
true, 112123, 64,
|
|
true, 112123, 64,
|
|
},
|
|
{
|
|
STRPLUSLEN("ab/cdef/g/hij"),
|
|
true, 54654, 58,
|
|
true, 54654, 58,
|
|
},
|
|
{
|
|
STRPLUSLEN("ab/cdef/gh/i"),
|
|
true, 5464154, 4,
|
|
true, 5464154, 4,
|
|
},
|
|
{
|
|
STRPLUSLEN("ab/cdef/gh/ijk"),
|
|
true, 45645105, 65,
|
|
true, 45645105, 65,
|
|
},
|
|
{
|
|
STRPLUSLEN("ab/cdef/ghi"),
|
|
true, 44252, 22,
|
|
true, 44252, 22,
|
|
},
|
|
{
|
|
STRPLUSLEN("abc"),
|
|
true, 12345, 5,
|
|
true, 12345, 5,
|
|
},
|
|
};
|
|
diff_expectations_t include_all_expectations = {
|
|
include_all_expectation_array,
|
|
0, sizeof(include_all_expectation_array) / sizeof(diff_expectation_t)
|
|
};
|
|
|
|
ASSERT(diff_trees(
|
|
left, right,
|
|
true,
|
|
expectations_matcher, &include_all_expectations) == DIFF_OK);
|
|
ASSERT(include_all_expectations.expectations_idx ==
|
|
include_all_expectations.expectations_sz);
|
|
}
|
|
|
|
/**
|
|
* Diff two trees with no identical names in the same directory.
|
|
*/
|
|
static void diff_no_identical_trees() {
|
|
tree_t *left = alloc_tree();
|
|
tree_t *right = alloc_tree();
|
|
|
|
add_to_tree_t toadd_left[] = {
|
|
{STRPLUSLEN("ab/cdef/ghi_left"), 44252, 22},
|
|
{STRPLUSLEN("ab/cdef/g/hi_left"), 112123, 64},
|
|
{STRPLUSLEN("ab/cdef/g/hij_left"), 54654, 58},
|
|
};
|
|
|
|
add_to_tree_t toadd_right[] = {
|
|
{STRPLUSLEN("ab/cdef/ghi_right"), 44252, 22},
|
|
{STRPLUSLEN("ab/cdef/g/hi_right"), 112123, 64},
|
|
{STRPLUSLEN("ab/cdef/g/hij_right"), 54654, 58},
|
|
};
|
|
|
|
add_to_tree(left, toadd_left, sizeof(toadd_left) / sizeof(add_to_tree_t));
|
|
add_to_tree(right, toadd_right, sizeof(toadd_right) / sizeof(add_to_tree_t));
|
|
|
|
diff_expectation_t expectation_array[] =
|
|
{
|
|
{
|
|
STRPLUSLEN("ab/cdef/g/hi_left"),
|
|
true, 112123, 64,
|
|
false, 0, 0,
|
|
},
|
|
{
|
|
STRPLUSLEN("ab/cdef/g/hi_right"),
|
|
false, 0, 0,
|
|
true, 112123, 64,
|
|
},
|
|
{
|
|
STRPLUSLEN("ab/cdef/g/hij_left"),
|
|
true, 54654, 58,
|
|
false, 0, 0,
|
|
},
|
|
{
|
|
STRPLUSLEN("ab/cdef/g/hij_right"),
|
|
false, 0, 0,
|
|
true, 54654, 58,
|
|
},
|
|
{
|
|
STRPLUSLEN("ab/cdef/ghi_left"),
|
|
true, 44252, 22,
|
|
false, 0, 0,
|
|
},
|
|
{
|
|
STRPLUSLEN("ab/cdef/ghi_right"),
|
|
false, 0, 0,
|
|
true, 44252, 22,
|
|
},
|
|
};
|
|
diff_expectations_t normal_expectations = {
|
|
expectation_array,
|
|
0, sizeof(expectation_array) / sizeof(diff_expectation_t)
|
|
};
|
|
|
|
ASSERT(diff_trees(
|
|
left, right,
|
|
false,
|
|
expectations_matcher, &normal_expectations) == DIFF_OK);
|
|
ASSERT(normal_expectations.expectations_idx ==
|
|
normal_expectations.expectations_sz);
|
|
|
|
diff_expectations_t include_all_expectations = {
|
|
expectation_array,
|
|
0, sizeof(expectation_array) / sizeof(diff_expectation_t)
|
|
};
|
|
|
|
ASSERT(diff_trees(
|
|
left, right,
|
|
true,
|
|
expectations_matcher, &include_all_expectations) == DIFF_OK);
|
|
ASSERT(include_all_expectations.expectations_idx ==
|
|
include_all_expectations.expectations_sz);
|
|
}
|
|
|
|
/**
|
|
* Diff two trees with a leaf vs implicit node difference.
|
|
*/
|
|
static void diff_different_types_trees() {
|
|
tree_t *left = alloc_tree();
|
|
tree_t *right = alloc_tree();
|
|
|
|
add_to_tree_t toadd_left[] = {
|
|
{STRPLUSLEN("ab/cdef/ghi_left"), 44252, 22},
|
|
};
|
|
|
|
add_to_tree_t toadd_right[] = {
|
|
{STRPLUSLEN("ab/cdef"), 44252, 22},
|
|
};
|
|
|
|
add_to_tree(left, toadd_left, sizeof(toadd_left) / sizeof(add_to_tree_t));
|
|
add_to_tree(right, toadd_right, sizeof(toadd_right) / sizeof(add_to_tree_t));
|
|
|
|
diff_expectation_t expectation_array[] =
|
|
{
|
|
{
|
|
STRPLUSLEN("ab/cdef"),
|
|
false, 0, 0,
|
|
true, 44252, 22,
|
|
},
|
|
{
|
|
STRPLUSLEN("ab/cdef/ghi_left"),
|
|
true, 44252, 22,
|
|
false, 0, 0,
|
|
},
|
|
};
|
|
diff_expectations_t normal_expectations = {
|
|
expectation_array,
|
|
0, sizeof(expectation_array) / sizeof(diff_expectation_t)
|
|
};
|
|
|
|
ASSERT(diff_trees(
|
|
left, right,
|
|
false,
|
|
expectations_matcher, &normal_expectations) == DIFF_OK);
|
|
ASSERT(normal_expectations.expectations_idx ==
|
|
normal_expectations.expectations_sz);
|
|
|
|
diff_expectations_t include_all_expectations = {
|
|
expectation_array,
|
|
0, sizeof(expectation_array) / sizeof(diff_expectation_t)
|
|
};
|
|
|
|
ASSERT(diff_trees(
|
|
left, right,
|
|
true,
|
|
expectations_matcher, &include_all_expectations) == DIFF_OK);
|
|
ASSERT(include_all_expectations.expectations_idx ==
|
|
include_all_expectations.expectations_sz);
|
|
}
|
|
|
|
/**
|
|
* Diff two trees with differences in the metadata.
|
|
*/
|
|
static void diff_different_metadata() {
|
|
tree_t *left = alloc_tree();
|
|
tree_t *right = alloc_tree();
|
|
|
|
add_to_tree_t toadd_left[] = {
|
|
{STRPLUSLEN("ab/cdef"), 44253, 22},
|
|
{STRPLUSLEN("ab/cdefg"), 44252, 23},
|
|
};
|
|
|
|
add_to_tree_t toadd_right[] = {
|
|
{STRPLUSLEN("ab/cdef"), 44252, 22},
|
|
{STRPLUSLEN("ab/cdefg"), 44252, 22},
|
|
};
|
|
|
|
add_to_tree(left, toadd_left, sizeof(toadd_left) / sizeof(add_to_tree_t));
|
|
add_to_tree(right, toadd_right, sizeof(toadd_right) / sizeof(add_to_tree_t));
|
|
|
|
diff_expectation_t expectation_array[] =
|
|
{
|
|
{
|
|
STRPLUSLEN("ab/cdef"),
|
|
true, 44253, 22,
|
|
true, 44252, 22,
|
|
},
|
|
{
|
|
STRPLUSLEN("ab/cdefg"),
|
|
true, 44252, 23,
|
|
true, 44252, 22,
|
|
},
|
|
};
|
|
diff_expectations_t normal_expectations = {
|
|
expectation_array,
|
|
0, sizeof(expectation_array) / sizeof(diff_expectation_t)
|
|
};
|
|
|
|
ASSERT(diff_trees(
|
|
left, right,
|
|
false,
|
|
expectations_matcher, &normal_expectations) == DIFF_OK);
|
|
ASSERT(normal_expectations.expectations_idx ==
|
|
normal_expectations.expectations_sz);
|
|
|
|
diff_expectations_t include_all_expectations = {
|
|
expectation_array,
|
|
0, sizeof(expectation_array) / sizeof(diff_expectation_t)
|
|
};
|
|
|
|
ASSERT(diff_trees(
|
|
left, right,
|
|
true,
|
|
expectations_matcher, &include_all_expectations) == DIFF_OK);
|
|
ASSERT(include_all_expectations.expectations_idx ==
|
|
include_all_expectations.expectations_sz);
|
|
}
|
|
|
|
int main(int argc, char *argv[]) {
|
|
diff_empty_trees();
|
|
diff_identical_trees();
|
|
diff_no_identical_trees();
|
|
diff_different_types_trees();
|
|
diff_different_metadata();
|
|
|
|
return 0;
|
|
}
|