Significantly expand backend tests.

Author: hypernewbie

demo/demo.cpp

@@ -850,6 +850,48 @@ static void clear_backend_test_surfaces()
 	glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 }
 
+static void backend_test_reset_surfaces()
+{
+	clear_backend_test_surfaces();
+	glFinish();
+}
+
+static bool backend_test_write_surface( const char* name, int x, int y, int w, int h, const uint8_t* pixels )
+{
+	if ( !name || !pixels || x < 0 || y < 0 || w <= 0 || h <= 0 ) {
+		return false;
+	}
+
+	GLuint texture = 0;
+	int texture_width = 0;
+	int texture_height = 0;
+	if ( std::strcmp( name, "glyph_buffer" ) == 0 ) {
+		texture = fontcache_fbo_texture[ 0 ];
+		texture_width = VE_FONTCACHE_GLYPHDRAW_BUFFER_WIDTH;
+		texture_height = VE_FONTCACHE_GLYPHDRAW_BUFFER_HEIGHT;
+	} else if ( std::strcmp( name, "atlas" ) == 0 ) {
+		texture = fontcache_fbo_texture[ 1 ];
+		texture_width = VE_FONTCACHE_ATLAS_WIDTH;
+		texture_height = VE_FONTCACHE_ATLAS_HEIGHT;
+	} else {
+		return false;
+	}
+
+	if ( x + w > texture_width || y + h > texture_height ) {
+		return false;
+	}
+
+	GLint previous_texture = 0;
+	glGetIntegerv( GL_TEXTURE_BINDING_2D, &previous_texture );
+	glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
+	glBindTexture( GL_TEXTURE_2D, texture );
+	glTexSubImage2D( GL_TEXTURE_2D, 0, x, y, w, h, GL_RED, GL_UNSIGNED_BYTE, pixels );
+	glBindTexture( GL_TEXTURE_2D, static_cast< GLuint >( previous_texture ) );
+	glFinish();
+	check_error( __LINE__ );
+	return true;
+}
+
 static bool backend_test_readback( const char* name, int x, int y, int w, int h, uint8_t* out_pixels )
 {
 	GLint previous_read_framebuffer = 0;
@@ -933,6 +975,8 @@ static int run_backend_test_mode()
 	options.huge_font = huge_test_font;
 	options.execute = backend_test_execute;
 	options.readback = backend_test_readback;
+	options.reset_surfaces = backend_test_reset_surfaces;
+	options.write_surface = backend_test_write_surface;
 	options.reload_font = [ &reload_buffers ]() -> ve_font_id {
 		reload_buffers.emplace_back();
 		return load_demo_font( &cache, "fonts/NotoSansJP-Light.otf", reload_buffers.back(), 19.0f );

demo/demo_dx11.cpp

@@ -560,12 +560,12 @@ DX_CHECK( g_context->Map( staging, 0, D3D11_MAP_READ, 0, &mapped ) );
 if ( source_desc.Format == DXGI_FORMAT_R8_UNORM ) {
 for ( int row = 0; row < h; row++ ) {
 const uint8_t* src = static_cast< const uint8_t* >( mapped.pData ) + row * mapped.RowPitch;
-std::memcpy( out_pixels + row * w, src, static_cast< size_t >( w ) );
+std::memcpy( out_pixels + static_cast< size_t >( h - 1 - row ) * w, src, static_cast< size_t >( w ) );
 }
 } else if ( source_desc.Format == DXGI_FORMAT_R8G8B8A8_UNORM ) {
 for ( int row = 0; row < h; row++ ) {
 const uint8_t* src = static_cast< const uint8_t* >( mapped.pData ) + row * mapped.RowPitch;
-uint8_t* dst = out_pixels + row * w;
+uint8_t* dst = out_pixels + static_cast< size_t >( h - 1 - row ) * w;
 for ( int col = 0; col < w; col++ ) {
 dst[ col ] = src[ col * 4 ];
 }
@@ -606,7 +606,7 @@ static void dx11_update_texture_region_from_greyscale( ID3D11Texture2D* texture,
 	std::vector< uint8_t > rgba_pixels( static_cast< size_t >( w ) * static_cast< size_t >( h ) * 4 );
 	for ( int row = 0; row < h; row++ ) {
 		for ( int col = 0; col < w; col++ ) {
-			const uint8_t value = pixels[ static_cast< size_t >( row ) * w + col ];
+			const uint8_t value = pixels[ static_cast< size_t >( h - 1 - row ) * w + col ];
 			const size_t dst_index = ( static_cast< size_t >( row ) * w + col ) * 4;
 			rgba_pixels[ dst_index + 0 ] = value;
 			rgba_pixels[ dst_index + 1 ] = value;
@@ -1509,6 +1509,53 @@ clear_framebuffer_colour( g_backbuffer_rtv );
 g_context->Flush();
 }
 
+static void backend_test_reset_surfaces()
+{
+	clear_backend_test_surfaces();
+	g_context->Flush();
+}
+
+static bool backend_test_write_surface( const char* name, int x, int y, int w, int h, const uint8_t* pixels )
+{
+	if ( !name || !pixels || x < 0 || y < 0 || w <= 0 || h <= 0 ) {
+		return false;
+	}
+
+	if ( std::strcmp( name, "glyph_buffer" ) == 0 ) {
+		if ( x + w > VE_FONTCACHE_GLYPHDRAW_BUFFER_WIDTH || y + h > VE_FONTCACHE_GLYPHDRAW_BUFFER_HEIGHT ) {
+			return false;
+		}
+		dx11_update_texture_region_from_greyscale(
+			g_glyph_buffer.texture,
+			VE_FONTCACHE_GLYPHDRAW_BUFFER_HEIGHT,
+			x,
+			y,
+			w,
+			h,
+			pixels );
+		g_context->Flush();
+		return true;
+	}
+
+	if ( std::strcmp( name, "atlas" ) == 0 ) {
+		if ( x + w > VE_FONTCACHE_ATLAS_WIDTH || y + h > VE_FONTCACHE_ATLAS_HEIGHT ) {
+			return false;
+		}
+		dx11_update_texture_region_from_greyscale(
+			g_atlas.texture,
+			VE_FONTCACHE_ATLAS_HEIGHT,
+			x,
+			y,
+			w,
+			h,
+			pixels );
+		g_context->Flush();
+		return true;
+	}
+
+	return false;
+}
+
 static bool backend_test_readback( const char* name, int x, int y, int w, int h, uint8_t* out_pixels )
 {
 if ( std::strcmp( name, "glyph_buffer" ) == 0 ) {
@@ -1578,6 +1625,8 @@ options.cjk_font = cjk_test_font;
 options.huge_font = huge_test_font;
 options.execute = backend_test_execute;
 options.readback = backend_test_readback;
+options.reset_surfaces = backend_test_reset_surfaces;
+options.write_surface = backend_test_write_surface;
 options.reload_font = [ &reload_buffers ]() -> ve_font_id {
 reload_buffers.emplace_back();
 return load_demo_font( &cache, "fonts/NotoSansJP-Light.otf", reload_buffers.back(), 19.0f );

tests/test_backend_diagnostics.cpp

@@ -0,0 +1,94 @@
+#include "test_common.h"
+
+UTEST( backend_diagnostics, bbox_profiles_and_centroid )
+{
+	std::vector< uint8_t > pixels = ve_fontcache_backend_test_make_image( 8, 8, 0 );
+	ve_fontcache_backend_test_fill_rect( pixels, 8, 8, 2, 1, 3, 4, 20 );
+
+	ve_fontcache_backend_test_bbox bbox = ve_fontcache_backend_test_thresholded_bbox( pixels, 8, 8, 1 );
+	std::vector< uint32_t > rows = ve_fontcache_backend_test_row_sum_profile( pixels, 8, 8 );
+	std::vector< uint32_t > cols = ve_fontcache_backend_test_column_sum_profile( pixels, 8, 8 );
+	ve_fontcache_backend_test_center_of_mass center = ve_fontcache_backend_test_center_of_mass_grayscale( pixels, 8, 8 );
+
+	EXPECT_TRUE( bbox.valid );
+	EXPECT_EQ( 2, bbox.x );
+	EXPECT_EQ( 1, bbox.y );
+	EXPECT_EQ( 3, bbox.w );
+	EXPECT_EQ( 4, bbox.h );
+	EXPECT_EQ( 12, bbox.area );
+	EXPECT_EQ( 60u, rows[ 1 ] );
+	EXPECT_EQ( 60u, rows[ 4 ] );
+	EXPECT_EQ( 80u, cols[ 2 ] );
+	EXPECT_EQ( 80u, cols[ 4 ] );
+	EXPECT_TRUE( std::fabs( center.x - 3.5 ) <= 0.01 );
+	EXPECT_TRUE( std::fabs( center.y - 3.0 ) <= 0.01 );
+}
+
+UTEST( backend_diagnostics, components_and_border_leakage )
+{
+	std::vector< uint8_t > pixels = ve_fontcache_backend_test_make_image( 6, 6, 0 );
+	ve_fontcache_backend_test_fill_rect( pixels, 6, 6, 1, 1, 2, 2, 255 );
+	ve_fontcache_backend_test_fill_rect( pixels, 6, 6, 0, 5, 1, 1, 255 );
+
+	EXPECT_EQ( 2, ve_fontcache_backend_test_connected_component_count( pixels, 6, 6, 1 ) );
+	EXPECT_EQ( 1, ve_fontcache_backend_test_border_leakage_count( pixels, 6, 6, 1, 1 ) );
+	EXPECT_EQ( 1, ve_fontcache_backend_test_outside_rect_count( pixels, 6, 6, { 1, 1, 2, 2 }, 1 ) );
+}
+
+UTEST( backend_diagnostics, diff_stats_and_peak_location )
+{
+	std::vector< uint8_t > expected = ve_fontcache_backend_test_make_image( 4, 4, 0 );
+	std::vector< uint8_t > actual = expected;
+	actual[ 1 ] = 20;
+	actual[ 14 ] = 120;
+
+	ve_fontcache_backend_test_diff_stats diff = ve_fontcache_backend_test_expected_vs_actual_diff( expected, actual, 4, 4 );
+
+	EXPECT_EQ( 140ull, diff.total_abs_error );
+	EXPECT_TRUE( std::fabs( diff.mean_abs_error - 8.75 ) <= 0.01 );
+	EXPECT_EQ( 120, diff.max_abs_error );
+	EXPECT_EQ( 2, diff.peak_x );
+	EXPECT_EQ( 3, diff.peak_y );
+	EXPECT_EQ( 2, diff.differing_pixels );
+}
+
+UTEST( backend_diagnostics, mirror_scores_detect_flips )
+{
+	std::vector< uint8_t > expected = ve_fontcache_backend_test_make_image( 6, 6, 0 );
+	ve_fontcache_backend_test_fill_l_shape( expected, 6, 6, 1, 1, 4, 4, 2, 255 );
+
+	std::vector< uint8_t > vertical = ve_fontcache_backend_test_flip_vertical( expected, 6, 6 );
+	std::vector< uint8_t > horizontal = ve_fontcache_backend_test_flip_horizontal( expected, 6, 6 );
+
+	ve_fontcache_backend_test_mirror_scores vertical_scores =
+		ve_fontcache_backend_test_mirror_scores_for_expected( expected, vertical, 6, 6 );
+	ve_fontcache_backend_test_mirror_scores horizontal_scores =
+		ve_fontcache_backend_test_mirror_scores_for_expected( expected, horizontal, 6, 6 );
+
+	EXPECT_TRUE( ve_fontcache_backend_test_is_vertical_flip( vertical_scores ) );
+	EXPECT_FALSE( ve_fontcache_backend_test_is_horizontal_flip( vertical_scores ) );
+	EXPECT_TRUE( ve_fontcache_backend_test_is_horizontal_flip( horizontal_scores ) );
+	EXPECT_FALSE( ve_fontcache_backend_test_is_vertical_flip( horizontal_scores ) );
+}
+
+UTEST( backend_diagnostics, classifier_helpers_flag_scale_aspect_and_source_binding )
+{
+	ve_fontcache_backend_test_bbox expected_bbox { true, 10, 20, 40, 40, 1600 };
+	ve_fontcache_backend_test_bbox uniform_scaled { true, 12, 22, 48, 48, 2304 };
+	ve_fontcache_backend_test_bbox aspect_scaled { true, 12, 22, 56, 40, 2240 };
+
+	EXPECT_TRUE( ve_fontcache_backend_test_is_uniform_scale_error( expected_bbox, uniform_scaled ) );
+	EXPECT_FALSE( ve_fontcache_backend_test_is_aspect_ratio_deformation( expected_bbox, uniform_scaled ) );
+	EXPECT_TRUE( ve_fontcache_backend_test_is_aspect_ratio_deformation( expected_bbox, aspect_scaled ) );
+
+	std::vector< uint8_t > pattern = ve_fontcache_backend_test_make_image( 4, 4, 0 );
+	ve_fontcache_backend_test_fill_rect( pattern, 4, 4, 0, 0, 2, 4, 255 );
+	std::vector< uint8_t > zero = ve_fontcache_backend_test_make_image( 4, 4, 0 );
+
+	ve_fontcache_backend_test_diff_stats expected_diff =
+		ve_fontcache_backend_test_expected_vs_actual_diff( pattern, zero, 4, 4 );
+	ve_fontcache_backend_test_diff_stats alternate_diff =
+		ve_fontcache_backend_test_expected_vs_actual_diff( zero, zero, 4, 4 );
+
+	EXPECT_TRUE( ve_fontcache_backend_test_is_wrong_source_texture_bound( expected_diff, alternate_diff ) );
+}

tests/test_main.cpp

@@ -32,6 +32,7 @@
 #include "test_font_load.cpp"
 #include "test_drawlist.cpp"
 #include "test_backend.cpp"
+#include "test_backend_diagnostics.cpp"
 #include "test_shape_cache.cpp"
 #include "test_utf8.cpp"
 #include "test_stress.cpp"

tests/test_shape_cache_eviction.cpp

@@ -67,7 +67,7 @@ UTEST( shape_cache_eviction, cursor_pos_correct_after_eviction )
 	float second_cursor_x = ctx.cache.cursor_pos.x;
 
 	// The cursor positions should match (same layout reproduced)
-	EXPECT_NEAR( first_cursor_x, second_cursor_x, 0.1f );
+	EXPECT_TRUE( std::fabs( first_cursor_x - second_cursor_x ) <= 0.1f );
 }
 
 UTEST( shape_cache_eviction, next_cache_idx_wraps )
@@ -103,4 +103,4 @@ UTEST( shape_cache_eviction, next_cache_idx_wraps )
 
 	// Verify final state is still within bounds
 	EXPECT_LE( ctx.cache.shape_cache.state.cache.size(), static_cast< size_t >( VE_FONTCACHE_SHAPECACHE_SIZE ) );
-}
+}