/*ds18b20_hex2temperature -- Caculate temperature according to hex_value*/
float ds18b20_hex2temperature(unsigned short hex_value)
{
int bit_index = 0;
float temperature = 0.0f;
if (IS_NEGATIVE(hex_value)){
hex_value--;
while (bit_index <= DS18B20_TEMPERATURE_DATA_MAX_BIT){
if ((hex_value & (1 << bit_index)) == 0){
temperature += BIT2VALUE(bit_index);
}
bit_index++;
}
temperature = -temperature;
}else{
while (bit_index <= DS18B20_TEMPERATURE_DATA_MAX_BIT){
if (hex_value & (1 << bit_index)){
temperature += BIT2VALUE(bit_index);
}
bit_index++;
}
}
return temperature;
}
/**
* @brief
* open with different users FS_MAX_OPEN_FILES open file entries (for less than FS_MAX_VNODES files),
* than another file and making sure the last open fails with
* the matching error
* @return 1 if successful, 0 otherwise
*/
error_t openTest9(){
user_id user1 = 1, user2 = 2;
uint32_t i, flags1 = NANDFS_O_RDONLY, flags2 = NANDFS_O_RDONLY;
int32_t fd1, fd2;
/* set user1 in process*/
SET_CURRENT_USER(user1);
fd1 = open(VALID_MOCK_FILE_NAME_1, flags1, 0);
// PRINT_MSG_AND_NUM("\nfd1=", fd1);
/* verify open for reading */
VERIFY(!COMPARE(fd1,FD_EMPTY));
VERIFY(verifyOpenFileEntry(fd1,flags1,0,user1,0));
VERIFY(verifyVnode(OPEN_FILE_GET_VNODE(fd1), VALID_MOCK_INO_NUM_1, 1));
/* set user2 in process*/
SET_CURRENT_USER(user2);
for(i=1;i<FS_MAX_OPEN_FILES;i++){
fd2 = open(VALID_MOCK_FILE_NAME_2, flags2, 0);
// PRINT_MSG_AND_NUM("\nfd2=", fd2);
/* verify open for reading */
VERIFY(!IS_NEGATIVE(fd2));
VERIFY(verifyOpenFileEntry(fd2,flags2,0,user2,1));
}
/* verify all other file entries are empty*/
for(i=0;i< FS_MAX_OPEN_FILES;i++){
VERIFY(!verifyOpenFileEntryEmpty(i));
}
/* verify all other vnodes are empty */
for(i=2;i< FS_MAX_VNODES;i++){
VERIFY(verifyVnodeEmpty(i));
}
/* now try opening again and verify failure */
fd2 = open(VALID_MOCK_FILE_NAME_2, flags2, 0);
// PRINT_MSG_AND_NUM("\nfd2=", fd2);
VERIFY(IS_NEGATIVE(fd2));
return 1;
}
/**
* @brief
* open a file that exists twice for reading
* should succeed
* @return 1 if successful, 0 otherwise
*/
error_t openTest5(){
user_id user1 = 1, user2 = 2;
uint32_t i, flags = NANDFS_O_RDONLY;
int32_t fd1, fd2;
/* set user1 in process*/
SET_CURRENT_USER(user1);
fd1 = open(VALID_MOCK_FILE_NAME_1, flags, 0);
/* verify open */
VERIFY(!IS_NEGATIVE(fd1));
VERIFY(verifyOpenFileEntry(fd1,flags,0,user1,0));
VERIFY(verifyVnode(OPEN_FILE_GET_VNODE(fd1), VALID_MOCK_INO_NUM_1, 1));
/* set user2 in process*/
SET_CURRENT_USER(user2);
fd2 = open(VALID_MOCK_FILE_NAME_1, flags, 0);
/* verify open*/
VERIFY(!IS_NEGATIVE(fd2));
VERIFY(verifyOpenFileEntry(fd2,flags,0,user2,0));
VERIFY(verifyVnode(OPEN_FILE_GET_VNODE(fd2), VALID_MOCK_INO_NUM_1, 2));
/* verify all other file entries are empty*/
for(i=0;i< FS_MAX_OPEN_FILES;i++){
if(i==fd1 || i == fd2)
continue;
VERIFY(verifyOpenFileEntryEmpty(i));
}
/* verify all other vnodes are empty */
for(i=0;i< FS_MAX_VNODES;i++){
if(i==OPEN_FILE_GET_VNODE(fd1) || i==OPEN_FILE_GET_VNODE(fd2))
continue;
VERIFY(verifyVnodeEmpty(i));
}
return 1;
}
/**
* @brief
* try opening a pathname that leads to a directory with write permission.
* should fail
* @return 1 if successful, 0 otherwise
*/
error_t openTest23(){
int32_t res;
/* try opening root directory for reading and verify success*/
res = open("/", NANDFS_O_RDONLY, 0);
VERIFY(!res);
/* try opening root directory for writing and verify failure*/
res = open("/", NANDFS_O_WRONLY, 0);
VERIFY(IS_NEGATIVE(res));
return 1;
}
bool OBResidue::GetAminoAcidProperty(int property) const
{
switch(property)
{
case OBAminoAcidProperty::ACIDIC:
return IS_ACIDIC(_aakey) != 0;
case OBAminoAcidProperty::ACYCLIC:
return IS_ACYCLIC(_aakey) != 0;
case OBAminoAcidProperty::ALIPHATIC:
return IS_ALIPHATIC(_aakey) != 0;
case OBAminoAcidProperty::AROMATIC:
return IS_AROMATIC(_aakey) != 0;
case OBAminoAcidProperty::BASIC:
return IS_BASIC(_aakey) != 0;
case OBAminoAcidProperty::BURIED:
return IS_BURIED(_aakey) != 0;
case OBAminoAcidProperty::CHARGED:
return IS_CHARGED(_aakey) != 0;
case OBAminoAcidProperty::CYCLIC:
return IS_CYCLIC(_aakey) != 0;
case OBAminoAcidProperty::HYDROPHOBIC:
return IS_HYDROPHOBIC(_aakey) != 0;
case OBAminoAcidProperty::LARGE:
return IS_LARGE(_aakey) != 0;
case OBAminoAcidProperty::MEDIUM:
return IS_MEDIUM(_aakey) != 0;
case OBAminoAcidProperty::NEGATIVE:
return IS_NEGATIVE(_aakey) != 0;
case OBAminoAcidProperty::NEUTRAL:
return IS_NEUTRAL(_aakey) != 0;
case OBAminoAcidProperty::POLAR:
return IS_POLAR(_aakey) != 0;
case OBAminoAcidProperty::POSITIVE:
return IS_POSITIVE(_aakey) != 0;
case OBAminoAcidProperty::SMALL:
return IS_SMALL(_aakey) != 0;
case OBAminoAcidProperty::SURFACE:
return IS_SURFACE(_aakey) != 0;
default:
return false;
}
}
/**
* @brief
* open a file that doesn't exists for writing
* should fail
* @return 1 if successful, 0 otherwise
*/
error_t openTest4(){
user_id user = 1;
uint32_t i, flags = NANDFS_O_WRONLY;
int32_t fd;
/* set user in process*/
SET_CURRENT_USER(user);
fd = open(INVALID_MOCK_FILE_NAME_1, flags, 0);
VERIFY(IS_NEGATIVE(fd));
/* verify all file entries are empty*/
for(i=0;i< FS_MAX_OPEN_FILES;i++){
VERIFY(verifyOpenFileEntryEmpty(i));
}
/* verify all other vnodes are empty */
for(i=0;i< FS_MAX_VNODES;i++){
VERIFY(verifyVnodeEmpty(i));
}
return 1;
}
static inline INT32 SX(INT32 x) { return IS_NEGATIVE(x) ? x | 0xff000000 : x & 0x00ffffff; }
/* Clip a triangle against the viewport and user clip planes.
*/
static void
do_clip_tri( struct draw_stage *stage,
struct prim_header *header,
unsigned clipmask )
{
struct clip_stage *clipper = clip_stage( stage );
struct vertex_header *a[MAX_CLIPPED_VERTICES];
struct vertex_header *b[MAX_CLIPPED_VERTICES];
struct vertex_header **inlist = a;
struct vertex_header **outlist = b;
unsigned tmpnr = 0;
unsigned n = 3;
unsigned i;
boolean aEdges[MAX_CLIPPED_VERTICES];
boolean bEdges[MAX_CLIPPED_VERTICES];
boolean *inEdges = aEdges;
boolean *outEdges = bEdges;
inlist[0] = header->v[0];
inlist[1] = header->v[1];
inlist[2] = header->v[2];
/*
* Note: at this point we can't just use the per-vertex edge flags.
* We have to observe the edge flag bits set in header->flags which
* were set during primitive decomposition. Put those flags into
* an edge flags array which parallels the vertex array.
* Later, in the 'unfilled' pipeline stage we'll draw the edge if both
* the header.flags bit is set AND the per-vertex edgeflag field is set.
*/
inEdges[0] = !!(header->flags & DRAW_PIPE_EDGE_FLAG_0);
inEdges[1] = !!(header->flags & DRAW_PIPE_EDGE_FLAG_1);
inEdges[2] = !!(header->flags & DRAW_PIPE_EDGE_FLAG_2);
while (clipmask && n >= 3) {
const unsigned plane_idx = ffs(clipmask)-1;
const boolean is_user_clip_plane = plane_idx >= 6;
const float *plane = clipper->plane[plane_idx];
struct vertex_header *vert_prev = inlist[0];
boolean *edge_prev = &inEdges[0];
float dp_prev = dot4( vert_prev->clip, plane );
unsigned outcount = 0;
clipmask &= ~(1<<plane_idx);
assert(n < MAX_CLIPPED_VERTICES);
if (n >= MAX_CLIPPED_VERTICES)
return;
inlist[n] = inlist[0]; /* prevent rotation of vertices */
inEdges[n] = inEdges[0];
for (i = 1; i <= n; i++) {
struct vertex_header *vert = inlist[i];
boolean *edge = &inEdges[i];
float dp = dot4( vert->clip, plane );
if (!IS_NEGATIVE(dp_prev)) {
assert(outcount < MAX_CLIPPED_VERTICES);
if (outcount >= MAX_CLIPPED_VERTICES)
return;
outEdges[outcount] = *edge_prev;
outlist[outcount++] = vert_prev;
}
if (DIFFERENT_SIGNS(dp, dp_prev)) {
struct vertex_header *new_vert;
boolean *new_edge;
assert(tmpnr < MAX_CLIPPED_VERTICES + 1);
if (tmpnr >= MAX_CLIPPED_VERTICES + 1)
return;
new_vert = clipper->stage.tmp[tmpnr++];
assert(outcount < MAX_CLIPPED_VERTICES);
if (outcount >= MAX_CLIPPED_VERTICES)
return;
new_edge = &outEdges[outcount];
outlist[outcount++] = new_vert;
if (IS_NEGATIVE(dp)) {
/* Going out of bounds. Avoid division by zero as we
* know dp != dp_prev from DIFFERENT_SIGNS, above.
*/
float t = dp / (dp - dp_prev);
interp( clipper, new_vert, t, vert, vert_prev );
/* Whether or not to set edge flag for the new vert depends
* on whether it's a user-defined clipping plane. We're
* copying NVIDIA's behaviour here.
*/
if (is_user_clip_plane) {
/* we want to see an edge along the clip plane */
*new_edge = TRUE;
new_vert->edgeflag = TRUE;
}
else {
/* we don't want to see an edge along the frustum clip plane */
*new_edge = *edge_prev;
new_vert->edgeflag = FALSE;
}
}
else {
/* Coming back in.
*/
float t = dp_prev / (dp_prev - dp);
interp( clipper, new_vert, t, vert_prev, vert );
/* Copy starting vert's edgeflag:
*/
new_vert->edgeflag = vert_prev->edgeflag;
*new_edge = *edge_prev;
}
}
vert_prev = vert;
edge_prev = edge;
dp_prev = dp;
}
/* swap in/out lists */
{
struct vertex_header **tmp = inlist;
inlist = outlist;
outlist = tmp;
n = outcount;
}
{
boolean *tmp = inEdges;
inEdges = outEdges;
outEdges = tmp;
}
}
/* If flat-shading, copy provoking vertex color to polygon vertex[0]
*/
if (n >= 3) {
if (clipper->flat) {
if (stage->draw->rasterizer->flatshade_first) {
if (inlist[0] != header->v[0]) {
assert(tmpnr < MAX_CLIPPED_VERTICES + 1);
if (tmpnr >= MAX_CLIPPED_VERTICES + 1)
return;
inlist[0] = dup_vert(stage, inlist[0], tmpnr++);
copy_colors(stage, inlist[0], header->v[0]);
}
}
else {
if (inlist[0] != header->v[2]) {
assert(tmpnr < MAX_CLIPPED_VERTICES + 1);
if (tmpnr >= MAX_CLIPPED_VERTICES + 1)
return;
inlist[0] = dup_vert(stage, inlist[0], tmpnr++);
copy_colors(stage, inlist[0], header->v[2]);
}
}
}
/* Emit the polygon as triangles to the setup stage:
*/
emit_poly( stage, inlist, inEdges, n, header );
}
}
constexpr int32_t SX(int32_t x) { return IS_NEGATIVE(x) ? x | 0xff000000 : x & 0x00ffffff; }
/* Clip a triangle against the viewport and user clip planes.
*/
static void
do_clip_tri( struct draw_stage *stage,
struct prim_header *header,
unsigned clipmask )
{
struct clipper *clipper = clipper_stage( stage );
struct vertex_header *a[MAX_CLIPPED_VERTICES];
struct vertex_header *b[MAX_CLIPPED_VERTICES];
struct vertex_header **inlist = a;
struct vertex_header **outlist = b;
unsigned tmpnr = 0;
unsigned n = 3;
unsigned i;
inlist[0] = header->v[0];
inlist[1] = header->v[1];
inlist[2] = header->v[2];
while (clipmask && n >= 3) {
const unsigned plane_idx = ffs(clipmask)-1;
const float *plane = clipper->plane[plane_idx];
struct vertex_header *vert_prev = inlist[0];
float dp_prev = dot4( vert_prev->clip, plane );
unsigned outcount = 0;
clipmask &= ~(1<<plane_idx);
inlist[n] = inlist[0]; /* prevent rotation of vertices */
for (i = 1; i <= n; i++) {
struct vertex_header *vert = inlist[i];
float dp = dot4( vert->clip, plane );
if (!IS_NEGATIVE(dp_prev)) {
outlist[outcount++] = vert_prev;
}
if (DIFFERENT_SIGNS(dp, dp_prev)) {
struct vertex_header *new_vert = clipper->stage.tmp[tmpnr++];
outlist[outcount++] = new_vert;
if (IS_NEGATIVE(dp)) {
/* Going out of bounds. Avoid division by zero as we
* know dp != dp_prev from DIFFERENT_SIGNS, above.
*/
float t = dp / (dp - dp_prev);
interp( clipper, new_vert, t, vert, vert_prev );
/* Force edgeflag true in this case:
*/
new_vert->edgeflag = 1;
} else {
/* Coming back in.
*/
float t = dp_prev / (dp_prev - dp);
interp( clipper, new_vert, t, vert_prev, vert );
/* Copy starting vert's edgeflag:
*/
new_vert->edgeflag = vert_prev->edgeflag;
}
}
vert_prev = vert;
dp_prev = dp;
}
{
struct vertex_header **tmp = inlist;
inlist = outlist;
outlist = tmp;
n = outcount;
}
}
/* If flat-shading, copy color to new provoking vertex.
*/
if (clipper->flat && inlist[0] != header->v[2]) {
if (1) {
inlist[0] = dup_vert(stage, inlist[0], tmpnr++);
}
copy_colors(stage, inlist[0], header->v[2]);
}
/* Emit the polygon as triangles to the setup stage:
*/
if (n >= 3)
emit_poly( stage, inlist, n, header );
}
/**
* @brief
* try opening a legal pathname with "." and ".."
* @return 1 if successful, 0 otherwise
*/
error_t openTest26(){
bool_t cpWritten;
INIT_LOGICAL_ADDRESS_STRUCT_AND_PTR(prev_log_addr);
INIT_LOGICAL_ADDRESS_STRUCT_AND_PTR(log_addr_file);
INIT_LOGICAL_ADDRESS_STRUCT_AND_PTR(log_addr_dir2);
INIT_LOGICAL_ADDRESS_STRUCT_AND_PTR(log_addr_dir1);
INIT_LOGICAL_ADDRESS_STRUCT_AND_PTR(log_addr_root);
INIT_LOGICAL_ADDRESS_STRUCT_AND_PTR(log_addr);
dirent_flash *dirent_ptr = CAST_TO_DIRENT(fs_buffer);
inode_t *ino_ptr = CAST_TO_INODE(fs_buffer);
uint8_t *f_full_name = "/directory1/../directory1/directory2/file1.dat";
uint32_t i;
int32_t fd, flags = NANDFS_O_RDONLY;
user_id user = 1;
init_logical_address(prev_log_addr);
init_logical_address(log_addr_file);
init_logical_address(log_addr_dir2);
init_logical_address(log_addr_dir1);
init_logical_address(log_addr_root);
init_logical_address(log_addr);
/* set user in process*/
SET_CURRENT_USER(user);
/* write file inode */
VERIFY(!writeNewInode(4, INO_NUM_EMPTY, FTYPE_FILE, log_addr_file));
/* write directory2 inode*/
VERIFY(!writeNewInode(3, 2, FTYPE_DIR, log_addr_dir2));
/* write directory1 inode*/
VERIFY(!writeNewInode(2, 1, FTYPE_DIR, log_addr_dir1));
/* write file1.dat direntry in directory2*/
VERIFY(!readFileBlock(fs_buffer, 3, INODE_FILE_DATA_SIZE, log_addr_dir2, TID_EMPTY));
/* iterate until we find an empty directory entry*/
while(!IS_DIRENT_EMPTY(dirent_ptr))
moveToNextDirentry(&dirent_ptr, DIRENT_GET_LEN(dirent_ptr));
setNewDirentry(dirent_ptr, 4, FTYPE_FILE, "file1.dat");
VERIFY(!allocAndWriteBlock(log_addr, fs_buffer, 0, prev_log_addr, &cpWritten, fsCheckpointWriter, 0));
/* write directory2 inode with new pointer to the above block*/
VERIFY(!fsReadBlockSimple(log_addr_dir2, fs_buffer));
INODE_SET_DIRECT(ino_ptr,0,log_addr);
VERIFY(!allocAndWriteBlock(log_addr_dir2, fs_buffer, 0, prev_log_addr, &cpWritten, fsCheckpointWriter, 0));
/* write directory2 direntry in directory1*/
VERIFY(!readFileBlock(fs_buffer, 2, INODE_FILE_DATA_SIZE, log_addr_dir1,TID_EMPTY));
/* iterate until we find an empty directory entry*/
while(!IS_DIRENT_EMPTY(dirent_ptr))
moveToNextDirentry(&dirent_ptr, DIRENT_GET_LEN(dirent_ptr));
setNewDirentry(dirent_ptr, 3, FTYPE_DIR, "directory2");
VERIFY(!allocAndWriteBlock(log_addr, fs_buffer, 0, prev_log_addr, &cpWritten, fsCheckpointWriter, 0));
/* write directory1 inode with new pointer to the above block*/
VERIFY(!fsReadBlockSimple(log_addr_dir1, fs_buffer));
INODE_SET_DIRECT(ino_ptr,0,log_addr);
VERIFY(!allocAndWriteBlock(log_addr_dir1, fs_buffer, 0, prev_log_addr, &cpWritten, fsCheckpointWriter, 0));
/* write directory1 direntry in root*/
VERIFY(!readFileBlock(fs_buffer, 1, INODE_FILE_DATA_SIZE, log_addr_root, TID_EMPTY));
/* iterate until we find an empty directory entry*/
while(!IS_DIRENT_EMPTY(dirent_ptr))
moveToNextDirentry(&dirent_ptr, DIRENT_GET_LEN(dirent_ptr));
setNewDirentry(dirent_ptr, 2, FTYPE_DIR, "directory1");
VERIFY(!allocAndWriteBlock(log_addr, fs_buffer, 0, prev_log_addr, &cpWritten, fsCheckpointWriter, 0));
/* write directory1 inode with new pointer to the above block*/
VERIFY(!fsReadBlockSimple(log_addr_root, fs_buffer));
INODE_SET_DIRECT(ino_ptr,0,log_addr);
VERIFY(!allocAndWriteBlock(log_addr_root, fs_buffer, 0, prev_log_addr, &cpWritten, fsCheckpointWriter, 0));
/* write inode0 with pointers to the new root address*/
VERIFY(!fsReadBlockSimple(FS_GET_INO0_ADDR_PTR(), fs_buffer));
INODE_SET_DIRECT(ino_ptr,0,log_addr_root);
INODE_SET_DIRECT(ino_ptr,1,log_addr_dir1);
INODE_SET_DIRECT(ino_ptr,2,log_addr_dir2);
INODE_SET_DIRECT(ino_ptr,3,log_addr_file);
INODE_SET_NBYTES(ino_ptr, CAST_VAL_TO_UINT32(INODE_FILE_DATA_SIZE+4*FS_BLOCK_SIZE));
VERIFY(!allocAndWriteBlock(FS_GET_INO0_ADDR_PTR(), fs_buffer, 0, prev_log_addr, &cpWritten, fsCheckpointWriter, 0));
/* and now try opening file1.dat*/
fd = open(f_full_name, flags, 0);
VERIFY(!IS_NEGATIVE(fd));
VERIFY(COMPARE(VNODE_GET_INO_NUM(OPEN_FILE_GET_VNODE(fd)), 4));
VERIFY(IS_RDONLY(OPEN_FILE_GET_FLAGS(fd)));
for(i=0; i< FS_MAX_OPEN_FILES;i++){
if(i==fd){
VERIFY(verifyOpenFileEntry(fd, flags,0,user, 0));
}
else{
VERIFY(verifyOpenFileEntryEmpty(i));
}
}
for(i=0; i<FS_MAX_VNODES;i++){
if(i!=fd){
VERIFY(verifyVnodeEmpty(i));
}
else{
VERIFY(verifyVnode(i, 4, 1));
}
}
//
return 1;
}
