diff --git a/lib/class-wp-theme-json-resolver-gutenberg.php b/lib/class-wp-theme-json-resolver-gutenberg.php
index 6e9d05cd7f238..1e825e3c6bbe4 100644
--- a/lib/class-wp-theme-json-resolver-gutenberg.php
+++ b/lib/class-wp-theme-json-resolver-gutenberg.php
@@ -275,7 +275,9 @@ public static function get_theme_data( $deprecated = array(), $options = array()
 			}
 
 			// BEGIN OF EXPERIMENTAL CODE. Not to backport to core.
-			static::$theme = WP_Fonts_Resolver::add_missing_fonts_to_theme_json( static::$theme );
+			if ( ! class_exists( 'WP_Font_Face' ) && class_exists( 'WP_Fonts_Resolver' ) ) {
+				static::$theme = WP_Fonts_Resolver::add_missing_fonts_to_theme_json( static::$theme );
+			}
 			// END OF EXPERIMENTAL CODE.
 
 		}
diff --git a/lib/compat/wordpress-6.3/script-loader.php b/lib/compat/wordpress-6.3/script-loader.php
index c515eb10fdc6b..8f7bda2a64811 100644
--- a/lib/compat/wordpress-6.3/script-loader.php
+++ b/lib/compat/wordpress-6.3/script-loader.php
@@ -81,7 +81,6 @@ function _gutenberg_get_iframed_editor_assets() {
 
 	ob_start();
 	wp_print_styles();
-	wp_print_fonts( true );
 	$styles = ob_get_clean();
 
 	ob_start();
diff --git a/lib/experimental/fonts-api/fonts-api.php b/lib/experimental/fonts-api/fonts-api.php
index e2ad6e1cb53af..8d07dc118f56e 100644
--- a/lib/experimental/fonts-api/fonts-api.php
+++ b/lib/experimental/fonts-api/fonts-api.php
@@ -243,3 +243,17 @@ static function( $mime_types ) {
  * during the build. See: tools/webpack/blocks.js.
  */
 add_action( 'init', 'WP_Fonts_Resolver::register_fonts_from_theme_json', 21 );
+
+add_filter(
+	'block_editor_settings_all',
+	static function( $settings ) {
+		ob_start();
+		wp_print_fonts( true );
+		$styles = ob_get_clean();
+
+		// Add the font-face styles to iframed editor assets.
+		$settings['__unstableResolvedAssets']['styles'] .= $styles;
+		return $settings;
+	},
+	11
+);
diff --git a/lib/experimental/fonts/class-wp-font-face-resolver.php b/lib/experimental/fonts/class-wp-font-face-resolver.php
new file mode 100644
index 0000000000000..16e74d6051aa7
--- /dev/null
+++ b/lib/experimental/fonts/class-wp-font-face-resolver.php
@@ -0,0 +1,158 @@
+<?php
+/**
+ * WP_Font_Face_Resolver class.
+ *
+ * @package    WordPress
+ * @subpackage Fonts
+ * @since      X.X.X
+ */
+
+if ( class_exists( 'WP_Font_Face_Resolver' ) ) {
+	return;
+}
+
+/**
+ * The Font Face Resolver abstracts the processing of different data sources
+ * (such as theme.json) for processing within the Font Face.
+ *
+ * This class is for internal core usage and is not supposed to be used by
+ * extenders (plugins and/or themes).
+ *
+ * @access private
+ */
+class WP_Font_Face_Resolver {
+
+	/**
+	 * Gets fonts defined in theme.json.
+	 *
+	 * @since X.X.X
+	 *
+	 * @return array Returns the font-families, each with their font-face variations.
+	 */
+	public static function get_fonts_from_theme_json() {
+		$settings = WP_Theme_JSON_Resolver_Gutenberg::get_merged_data()->get_settings();
+
+		// Bail out early if there are no font settings.
+		if ( empty( $settings['typography'] ) || empty( $settings['typography']['fontFamilies'] ) ) {
+			return array();
+		}
+
+		return static::parse_settings( $settings );
+	}
+
+	/**
+	 * Parse theme.json settings to extract font definitions with variations grouped by font-family.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param array $settings Font settings to parse.
+	 * @return array Returns an array of fonts, grouped by font-family.
+	 */
+	private static function parse_settings( array $settings ) {
+		$fonts = array();
+
+		foreach ( $settings['typography']['fontFamilies'] as $font_families ) {
+			foreach ( $font_families as $definition ) {
+
+				// Skip if font-family "name" is not defined.
+				if ( empty( $definition['name'] ) ) {
+					continue;
+				}
+
+				// Skip if "fontFace" is not defined, meaning there are no variations.
+				if ( empty( $definition['fontFace'] ) ) {
+					continue;
+				}
+
+				$font_family = $definition['name'];
+
+				// Prepare the fonts array structure for this font-family.
+				if ( ! array_key_exists( $font_family, $fonts ) ) {
+					$fonts[ $font_family ] = array();
+				}
+
+				$fonts[ $font_family ] = static::convert_font_face_properties( $definition['fontFace'], $font_family );
+			}
+		}
+
+		return $fonts;
+	}
+
+	/**
+	 * Converts font-face properties from theme.json format.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param array  $font_face_definition The font-face definitions to convert.
+	 * @param string $font_family_property The value to store in the font-face font-family property.
+	 * @return array Converted font-face properties.
+	 */
+	private static function convert_font_face_properties( array $font_face_definition, $font_family_property ) {
+		$converted_font_faces = array();
+
+		foreach ( $font_face_definition as $font_face ) {
+			// Add the font-family property to the font-face.
+			$font_face['font-family'] = $font_family_property;
+
+			// Converts the "file:./" src placeholder into a theme font file URI.
+			if ( ! empty( $font_face['src'] ) ) {
+				$font_face['src'] = static::to_theme_file_uri( (array) $font_face['src'] );
+			}
+
+			// Convert camelCase properties into kebab-case.
+			$font_face = static::to_kebab_case( $font_face );
+
+			$converted_font_faces[] = $font_face;
+		}
+
+		return $converted_font_faces;
+	}
+
+	/**
+	 * Converts each 'file:./' placeholder into a URI to the font file in the theme.
+	 *
+	 * The 'file:./' is specified in the theme's `theme.json` as a placeholder to be
+	 * replaced with the URI to the font file's location in the theme. When a "src"
+	 * beings with this placeholder, it is replaced, converting the src into a URI.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param array $src An array of font file sources to process.
+	 * @return array An array of font file src URI(s).
+	 */
+	private static function to_theme_file_uri( array $src ) {
+		$placeholder = 'file:./';
+
+		foreach ( $src as $src_key => $src_url ) {
+			// Skip if the src doesn't start with the placeholder, as there's nothing to replace.
+			if ( ! str_starts_with( $src_url, $placeholder ) ) {
+				continue;
+			}
+
+			$src_file        = str_replace( $placeholder, '', $src_url );
+			$src[ $src_key ] = get_theme_file_uri( $src_file );
+		}
+
+		return $src;
+	}
+
+	/**
+	 * Converts all first dimension keys into kebab-case.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param array $data The array to process.
+	 * @return array Data with first dimension keys converted into kebab-case.
+	 */
+	private static function to_kebab_case( array $data ) {
+		foreach ( $data as $key => $value ) {
+			$kebab_case          = _wp_to_kebab_case( $key );
+			$data[ $kebab_case ] = $value;
+			if ( $kebab_case !== $key ) {
+				unset( $data[ $key ] );
+			}
+		}
+
+		return $data;
+	}
+}
diff --git a/lib/experimental/fonts/class-wp-font-face.php b/lib/experimental/fonts/class-wp-font-face.php
new file mode 100644
index 0000000000000..482bf4d42396d
--- /dev/null
+++ b/lib/experimental/fonts/class-wp-font-face.php
@@ -0,0 +1,418 @@
+<?php
+/**
+ * WP_Font_Face class.
+ *
+ * @package    WordPress
+ * @subpackage Fonts
+ * @since      X.X.X
+ */
+
+if ( class_exists( 'WP_Font_Face' ) ) {
+	return;
+}
+
+/**
+ * Font Face generates and prints `@font-face` styles for given fonts.
+ *
+ * @since X.X.X
+ */
+class WP_Font_Face {
+
+	/**
+	 * The font-face property defaults.
+	 *
+	 * @since X.X.X
+	 *
+	 * @var string[]
+	 */
+	private $font_face_property_defaults = array(
+		'font-family'  => '',
+		'font-style'   => 'normal',
+		'font-weight'  => '400',
+		'font-display' => 'fallback',
+	);
+
+	/**
+	 * Valid font-face property names.
+	 *
+	 * @since X.X.X
+	 *
+	 * @var string[]
+	 */
+	private $valid_font_face_properties = array(
+		'ascent-override',
+		'descent-override',
+		'font-display',
+		'font-family',
+		'font-stretch',
+		'font-style',
+		'font-weight',
+		'font-variant',
+		'font-feature-settings',
+		'font-variation-settings',
+		'line-gap-override',
+		'size-adjust',
+		'src',
+		'unicode-range',
+	);
+
+	/**
+	 * Valid font-display values.
+	 *
+	 * @since X.X.X
+	 *
+	 * @var string[]
+	 */
+	private $valid_font_display = array( 'auto', 'block', 'fallback', 'swap', 'optional' );
+
+	/**
+	 * Array of font-face style tag's attribute(s)
+	 * where the key is the attribute name and the
+	 * value is its value.
+	 *
+	 * @since X.X.X
+	 *
+	 * @var string[]
+	 */
+	private $style_tag_attrs = array();
+
+	/**
+	 * Creates and initializes an instance of WP_Font_Face.
+	 *
+	 * @since X.X.X
+	 */
+	public function __construct() {
+		/**
+		 * Filters the font-face property defaults.
+		 *
+		 * @since X.X.X
+		 *
+		 * @param array $defaults {
+		 *     An array of required font-face properties and defaults.
+		 *
+		 *     @type string $provider     The provider ID. Default 'local'.
+		 *     @type string $font-family  The font-family property. Default empty string.
+		 *     @type string $font-style   The font-style property. Default 'normal'.
+		 *     @type string $font-weight  The font-weight property. Default '400'.
+		 *     @type string $font-display The font-display property. Default 'fallback'.
+		 * }
+		 */
+		$this->font_face_property_defaults = apply_filters( 'wp_font_face_property_defaults', $this->font_face_property_defaults );
+
+		if (
+			function_exists( 'is_admin' ) && ! is_admin()
+			&&
+			function_exists( 'current_theme_supports' ) && ! current_theme_supports( 'html5', 'style' )
+		) {
+			$this->style_tag_attrs = array( 'type' => 'text/css' );
+		}
+	}
+
+	/**
+	 * Generates and prints the `@font-face` styles for the given fonts.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param array $fonts The fonts to generate and print @font-face styles.
+	 */
+	public function generate_and_print( array $fonts ) {
+		$fonts = $this->validate_fonts( $fonts );
+
+		// Bail out if there are no fonts are given to process.
+		if ( empty( $fonts ) ) {
+			return;
+		}
+
+		printf(
+			$this->get_style_element(),
+			$this->get_css( $fonts )
+		);
+	}
+
+	/**
+	 * Validates each of the font-face properties.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param array $fonts The fonts to valid.
+	 * @return array Prepared font-faces organized by provider and font-family.
+	 */
+	private function validate_fonts( array $fonts ) {
+		$validated_fonts = array();
+
+		foreach ( $fonts as $font_faces ) {
+			foreach ( $font_faces as $font_face ) {
+				$font_face = $this->validate_font_face_properties( $font_face );
+				// Skip if failed validation.
+				if ( false === $font_face ) {
+					continue;
+				}
+
+				$validated_fonts[] = $font_face;
+			}
+		}
+
+		return $validated_fonts;
+	}
+
+	/**
+	 * Validates each font-face property.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param array $font_face Font face properties to validate.
+	 * @return false|array Validated font-face on success. Else, false.
+	 */
+	private function validate_font_face_properties( array $font_face ) {
+		$font_face = wp_parse_args( $font_face, $this->font_face_property_defaults );
+
+		// Check the font-family.
+		if ( empty( $font_face['font-family'] ) || ! is_string( $font_face['font-family'] ) ) {
+			trigger_error( 'Font font-family must be a non-empty string.' );
+			return false;
+		}
+
+		// Make sure that local fonts have 'src' defined.
+		if ( empty( $font_face['src'] ) || ( ! is_string( $font_face['src'] ) && ! is_array( $font_face['src'] ) ) ) {
+			trigger_error( 'Font src must be a non-empty string or an array of strings.' );
+			return false;
+		}
+
+		// Validate the 'src' property.
+		if ( ! empty( $font_face['src'] ) ) {
+			foreach ( (array) $font_face['src'] as $src ) {
+				if ( empty( $src ) || ! is_string( $src ) ) {
+					trigger_error( 'Each font src must be a non-empty string.' );
+					return false;
+				}
+			}
+		}
+
+		// Check the font-weight.
+		if ( ! is_string( $font_face['font-weight'] ) && ! is_int( $font_face['font-weight'] ) ) {
+			trigger_error( 'Font font-weight must be a properly formatted string or integer.' );
+			return false;
+		}
+
+		// Check the font-display.
+		if ( ! in_array( $font_face['font-display'], $this->valid_font_display, true ) ) {
+			$font_face['font-display'] = $this->font_face_property_defaults['font-display'];
+		}
+
+		// Remove invalid properties.
+		foreach ( $font_face as $prop => $value ) {
+			if ( ! in_array( $prop, $this->valid_font_face_properties, true ) ) {
+				unset( $font_face[ $prop ] );
+			}
+		}
+
+		return $font_face;
+	}
+
+	/**
+	 * Gets the `<style>` element for wrapping the `@font-face` CSS.
+	 *
+	 * @since X.X.X
+	 *
+	 * @return string The style element.
+	 */
+	private function get_style_element() {
+		$attributes = $this->generate_style_element_attributes();
+
+		return "<style id='wp-fonts-local'{$attributes}>\n%s\n</style>\n";
+	}
+
+	/**
+	 * Gets the defined <style> element's attributes.
+	 *
+	 * @since X.X.X
+	 *
+	 * @return string A string of attribute=value when defined, else, empty string.
+	 */
+	private function generate_style_element_attributes() {
+		$attributes = '';
+		foreach ( $this->style_tag_attrs as $name => $value ) {
+			$attributes .= " {$name}='{$value}'";
+		}
+		return $attributes;
+	}
+
+	/**
+	 * Gets the `@font-face` CSS styles for locally-hosted font files.
+	 *
+	 * This method does the following processing tasks:
+	 *    1. Orchestrates an optimized `src` (with format) for browser support.
+	 *    2. Generates the `@font-face` for all its fonts.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param array $font_faces The font-faces to generate @font-face CSS styles.
+	 * @return string The `@font-face` CSS styles.
+	 */
+	private function get_css( $font_faces ) {
+		$css = '';
+
+		foreach ( $font_faces as $font_face ) {
+				// Order the font's `src` items to optimize for browser support.
+				$font_face = $this->order_src( $font_face );
+
+				// Build the @font-face CSS for this font.
+				$css .= '@font-face{' . $this->build_font_face_css( $font_face ) . '}' . "\n";
+		}
+
+		// Don't print the last newline character.
+		return rtrim( $css, "\n" );
+	}
+
+	/**
+	 * Orders `src` items to optimize for browser support.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param array $font_face Font face to process.
+	 * @return array Font-face with ordered src items.
+	 */
+	private function order_src( array $font_face ) {
+		if ( ! is_array( $font_face['src'] ) ) {
+			$font_face['src'] = (array) $font_face['src'];
+		}
+
+		$src         = array();
+		$src_ordered = array();
+
+		foreach ( $font_face['src'] as $url ) {
+			// Add data URIs first.
+			if ( str_starts_with( trim( $url ), 'data:' ) ) {
+				$src_ordered[] = array(
+					'url'    => $url,
+					'format' => 'data',
+				);
+				continue;
+			}
+			$format         = pathinfo( $url, PATHINFO_EXTENSION );
+			$src[ $format ] = $url;
+		}
+
+		// Add woff2.
+		if ( ! empty( $src['woff2'] ) ) {
+			$src_ordered[] = array(
+				'url'    => $src['woff2'],
+				'format' => 'woff2',
+			);
+		}
+
+		// Add woff.
+		if ( ! empty( $src['woff'] ) ) {
+			$src_ordered[] = array(
+				'url'    => $src['woff'],
+				'format' => 'woff',
+			);
+		}
+
+		// Add ttf.
+		if ( ! empty( $src['ttf'] ) ) {
+			$src_ordered[] = array(
+				'url'    => $src['ttf'],
+				'format' => 'truetype',
+			);
+		}
+
+		// Add eot.
+		if ( ! empty( $src['eot'] ) ) {
+			$src_ordered[] = array(
+				'url'    => $src['eot'],
+				'format' => 'embedded-opentype',
+			);
+		}
+
+		// Add otf.
+		if ( ! empty( $src['otf'] ) ) {
+			$src_ordered[] = array(
+				'url'    => $src['otf'],
+				'format' => 'opentype',
+			);
+		}
+		$font_face['src'] = $src_ordered;
+
+		return $font_face;
+	}
+
+	/**
+	 * Builds the font-family's CSS.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param array $font_face Font face to process.
+	 * @return string This font-family's CSS.
+	 */
+	private function build_font_face_css( array $font_face ) {
+		$css = '';
+
+		// Wrap font-family in quotes if it contains spaces
+		// and is not already wrapped in quotes.
+		if (
+			str_contains( $font_face['font-family'], ' ' ) &&
+			! str_contains( $font_face['font-family'], '"' ) &&
+			! str_contains( $font_face['font-family'], "'" )
+		) {
+			$font_face['font-family'] = '"' . $font_face['font-family'] . '"';
+		}
+
+		foreach ( $font_face as $key => $value ) {
+			// Compile the "src" parameter.
+			if ( 'src' === $key ) {
+				$value = $this->compile_src( $value );
+			}
+
+			// If font-variation-settings is an array, convert it to a string.
+			if ( 'font-variation-settings' === $key && is_array( $value ) ) {
+				$value = $this->compile_variations( $value );
+			}
+
+			if ( ! empty( $value ) ) {
+				$css .= "$key:$value;";
+			}
+		}
+
+		return $css;
+	}
+
+	/**
+	 * Compiles the `src` into valid CSS.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param array $value Value to process.
+	 * @return string The CSS.
+	 */
+	private function compile_src( array $value ) {
+		$src = '';
+
+		foreach ( $value as $item ) {
+			$src .= ( 'data' === $item['format'] )
+				? ", url({$item['url']})"
+				: ", url('{$item['url']}') format('{$item['format']}')";
+		}
+
+		$src = ltrim( $src, ', ' );
+		return $src;
+	}
+
+	/**
+	 * Compiles the font variation settings.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param array $font_variation_settings Array of font variation settings.
+	 * @return string The CSS.
+	 */
+	private function compile_variations( array $font_variation_settings ) {
+		$variations = '';
+
+		foreach ( $font_variation_settings as $key => $value ) {
+			$variations .= "$key $value";
+		}
+
+		return $variations;
+	}
+}
diff --git a/lib/experimental/fonts/fonts.php b/lib/experimental/fonts/fonts.php
new file mode 100644
index 0000000000000..59e78d6059165
--- /dev/null
+++ b/lib/experimental/fonts/fonts.php
@@ -0,0 +1,58 @@
+<?php
+/**
+ * Fonts functions.
+ *
+ * @package    WordPress
+ * @subpackage Fonts
+ * @since      X.X.X
+ */
+
+add_action( 'wp_head', 'wp_print_font_faces', 50 );
+add_action( 'admin_print_styles', 'wp_print_font_faces', 50 );
+
+if ( ! function_exists( 'wp_print_font_faces' ) ) {
+	/**
+	 * Generates and prints font-face styles for given fonts or theme.json fonts.
+	 *
+	 * @since X.X.X
+	 *
+	 * @param array $fonts Optional. The fonts to generate and print @font-face styles.
+	 *                     Default empty array.
+	 */
+	function wp_print_font_faces( $fonts = array() ) {
+		static $wp_font_face = null;
+
+		if ( empty( $fonts ) ) {
+			$fonts = WP_Font_Face_Resolver::get_fonts_from_theme_json();
+		}
+
+		if ( empty( $fonts ) ) {
+			return;
+		}
+
+		if (
+			null === $wp_font_face ||
+
+			// Ignore cache when automated test suites are running.
+			( defined( 'WP_RUN_CORE_TESTS' ) && WP_RUN_CORE_TESTS )
+		) {
+			$wp_font_face = new WP_Font_Face();
+		}
+
+		$wp_font_face->generate_and_print( $fonts );
+	}
+}
+
+add_filter(
+	'block_editor_settings_all',
+	static function( $settings ) {
+		ob_start();
+		wp_print_font_faces();
+		$styles = ob_get_clean();
+
+		// Add the font-face styles to iframed editor assets.
+		$settings['__unstableResolvedAssets']['styles'] .= $styles;
+		return $settings;
+	},
+	11
+);
diff --git a/lib/load.php b/lib/load.php
index 3421bcc70d0b3..340a900130405 100644
--- a/lib/load.php
+++ b/lib/load.php
@@ -102,7 +102,6 @@ function gutenberg_is_experiment_enabled( $name ) {
 require_once __DIR__ . '/compat/wordpress-6.3/kses.php';
 
 // Experimental features.
-remove_action( 'plugins_loaded', '_wp_theme_json_webfonts_handler' ); // Turns off WP 6.0's stopgap handler for Webfonts API.
 require __DIR__ . '/experimental/behaviors.php';
 require __DIR__ . '/experimental/block-editor-settings-mobile.php';
 require __DIR__ . '/experimental/blocks.php';
@@ -129,8 +128,22 @@ function gutenberg_is_experiment_enabled( $name ) {
 require __DIR__ . '/experimental/interactivity-api/directives/wp-style.php';
 require __DIR__ . '/experimental/interactivity-api/directives/wp-text.php';
 
-// Fonts API.
-if ( ! class_exists( 'WP_Fonts' ) ) {
+// Fonts API / Font Face.
+remove_action( 'plugins_loaded', '_wp_theme_json_webfonts_handler' ); // Turns off WordPress 6.0's stopgap handler.
+
+/*
+ * If the Fonts Library is available, load the Font Face files, else load the Fonts API.
+ * This strategy is temporary until the Fonts Library is merged. It's used here to allow
+ * the Font Face (redesigned Fonts API) to be merged before the Fonts Library while
+ * keeping Fonts API available for sites that are using it.
+ */
+if ( class_exists( 'WP_Fonts_Library' ) || class_exists( 'WP_Fonts_Library_Controller' ) ) {
+	if ( ! class_exists( 'WP_Font_Face' ) ) {
+		require __DIR__ . '/experimental/fonts/class-wp-font-face.php';
+		require __DIR__ . '/experimental/fonts/class-wp-font-face-resolver.php';
+		require __DIR__ . '/experimental/fonts/fonts.php';
+	}
+} elseif ( ! class_exists( 'WP_Fonts' ) ) {
 	// Fonts API files.
 	require __DIR__ . '/experimental/fonts-api/class-wp-fonts-provider.php';
 	require __DIR__ . '/experimental/fonts-api/class-wp-fonts-utils.php';
diff --git a/phpunit/fonts/wp-font-face-testcase.php b/phpunit/fonts/wp-font-face-testcase.php
new file mode 100644
index 0000000000000..7f2603fbab663
--- /dev/null
+++ b/phpunit/fonts/wp-font-face-testcase.php
@@ -0,0 +1,187 @@
+<?php
+/**
+ * Test case for the Fonts tests.
+ *
+ * @package    WordPress
+ * @subpackage Fonts
+ */
+
+require_once __DIR__ . '/wp-font-face-tests-dataset.php';
+/**
+ * Abstracts the common tasks for the Font Face tests.
+ */
+abstract class WP_Font_Face_TestCase extends WP_UnitTestCase {
+	use WP_Font_Face_Tests_Datasets;
+
+	/**
+	 * Current error reporting level (before a test changes it).
+	 *
+	 * @var null|int
+	 */
+	protected $error_reporting_level = null;
+
+	/**
+	 * Reflection data store for non-public property access.
+	 *
+	 * @var ReflectionProperty[]
+	 */
+	protected $property = array();
+
+	/**
+	 * Indicates the test class uses `switch_theme()` and requires
+	 * set_up and tear_down fixtures to set and reset hooks and memory.
+	 *
+	 * If a test class switches themes, set this property to `true`.
+	 *
+	 * @var bool
+	 */
+	protected static $requires_switch_theme_fixtures = false;
+
+	/**
+	 * Theme root directory.
+	 *
+	 * @var string
+	 */
+	protected static $theme_root;
+
+	/**
+	 * Original theme directory.
+	 *
+	 * @var string
+	 */
+	protected $orig_theme_dir;
+
+	/**
+	 * Administrator ID.
+	 *
+	 * @var int
+	 */
+	protected static $administrator_id = 0;
+
+	public static function set_up_before_class() {
+		parent::set_up_before_class();
+
+		if ( self::$requires_switch_theme_fixtures ) {
+			self::$theme_root = realpath( __DIR__ . '/../data/themedir1' );
+		}
+	}
+
+	public static function tear_down_after_class() {
+		// Reset static flags.
+		self::$requires_switch_theme_fixtures = false;
+
+		parent::tear_down_after_class();
+	}
+
+	public function set_up() {
+		parent::set_up();
+
+		if ( self::$requires_switch_theme_fixtures ) {
+			$this->orig_theme_dir = $GLOBALS['wp_theme_directories'];
+
+			// /themes is necessary as theme.php functions assume /themes is the root if there is only one root.
+			$GLOBALS['wp_theme_directories'] = array( WP_CONTENT_DIR . '/themes', self::$theme_root );
+
+			// Set up the new root.
+			add_filter( 'theme_root', array( $this, 'filter_set_theme_root' ) );
+			add_filter( 'stylesheet_root', array( $this, 'filter_set_theme_root' ) );
+			add_filter( 'template_root', array( $this, 'filter_set_theme_root' ) );
+
+			// Clear caches.
+			wp_clean_themes_cache();
+			unset( $GLOBALS['wp_themes'] );
+		}
+	}
+
+	public function tear_down() {
+		$this->property = array();
+
+		// Reset the error reporting when modified within a test.
+		if ( is_int( $this->error_reporting_level ) ) {
+			error_reporting( $this->error_reporting_level );
+			$this->error_reporting_level = null;
+		}
+
+		if ( self::$requires_switch_theme_fixtures ) {
+			// Clean up the filters to modify the theme root.
+			remove_filter( 'theme_root', array( $this, 'filter_set_theme_root' ) );
+			remove_filter( 'stylesheet_root', array( $this, 'filter_set_theme_root' ) );
+			remove_filter( 'template_root', array( $this, 'filter_set_theme_root' ) );
+
+			WP_Theme_JSON_Resolver::clean_cached_data();
+			if ( class_exists( 'WP_Theme_JSON_Resolver_Gutenberg' ) ) {
+				WP_Theme_JSON_Resolver_Gutenberg::clean_cached_data();
+			}
+		}
+
+		parent::tear_down();
+	}
+
+	public function clean_up_global_scope() {
+		parent::clean_up_global_scope();
+
+		if ( self::$requires_switch_theme_fixtures ) {
+			$GLOBALS['wp_theme_directories'] = $this->orig_theme_dir;
+			wp_clean_themes_cache();
+
+			if ( function_exists( 'wp_clean_theme_json_cache' ) ) {
+				wp_clean_theme_json_cache();
+			}
+
+			if ( function_exists( '_gutenberg_clean_theme_json_caches' ) ) {
+				_gutenberg_clean_theme_json_caches();
+			}
+
+			unset( $GLOBALS['wp_themes'] );
+		}
+	}
+
+	public function filter_set_theme_root() {
+		return self::$theme_root;
+	}
+
+	protected function get_reflection_property( $property_name, $class = 'WP_Fonts' ) {
+		$property = new ReflectionProperty( $class, $property_name );
+		$property->setAccessible( true );
+
+		return $property;
+	}
+
+	protected function get_property_value( $property_name, $class, $wp_fonts = null ) {
+		$property = $this->get_reflection_property( $property_name, $class );
+
+		if ( ! $wp_fonts ) {
+			$wp_fonts = wp_fonts();
+		}
+
+		return $property->getValue( $wp_fonts );
+	}
+
+	protected function setup_property( $class, $property_name ) {
+		$key = $this->get_property_key( $class, $property_name );
+
+		if ( ! isset( $this->property[ $key ] ) ) {
+			$this->property[ $key ] = new ReflectionProperty( $class, 'providers' );
+			$this->property[ $key ]->setAccessible( true );
+		}
+
+		return $this->property[ $key ];
+	}
+
+	protected function get_property_key( $class, $property_name ) {
+		return $class . '::$' . $property_name;
+	}
+
+	/**
+	 * Opens the accessibility to access the given private or protected method.
+	 *
+	 * @param string $method_name Name of the method to open.
+	 * @return ReflectionMethod Instance of the method, ie to invoke it in the test.
+	 */
+	protected function get_reflection_method( $method_name ) {
+		$method = new ReflectionMethod( WP_Fonts::class, $method_name );
+		$method->setAccessible( true );
+
+		return $method;
+	}
+}
diff --git a/phpunit/fonts/wp-font-face-tests-dataset.php b/phpunit/fonts/wp-font-face-tests-dataset.php
new file mode 100644
index 0000000000000..00ae66e865a89
--- /dev/null
+++ b/phpunit/fonts/wp-font-face-tests-dataset.php
@@ -0,0 +1,274 @@
+<?php
+/**
+ * Datasets for unit and integration tests.
+ *
+ * @package    WordPress
+ * @subpackage Fonts
+ */
+
+/**
+ * Trait for reusing datasets within the Fonts tests.
+ */
+trait WP_Font_Face_Tests_Datasets {
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_should_print_given_fonts() {
+		return array(
+			'single truetype format font'    => array(
+				'fonts'    => array(
+					'Inter' =>
+						array(
+							array(
+								'src'          =>
+									array(
+										'https://example.org/assets/fonts/inter/Inter-VariableFont_slnt,wght.ttf',
+									),
+								'font-family'  => 'Inter',
+								'font-stretch' => 'normal',
+								'font-style'   => 'normal',
+								'font-weight'  => '200',
+							),
+						),
+				),
+				'expected' => <<<CSS
+@font-face{font-family:Inter;font-style:normal;font-weight:200;font-display:fallback;src:url('https://example.org/assets/fonts/inter/Inter-VariableFont_slnt,wght.ttf') format('truetype');font-stretch:normal;}
+CSS
+			,
+			),
+			'multiple truetype format fonts' => array(
+				'fonts'    => array(
+					'Inter' =>
+						array(
+							array(
+								'src'          =>
+									array(
+										'https://example.org/assets/fonts/inter/Inter-VariableFont_slnt,wght.ttf',
+									),
+								'font-family'  => 'Inter',
+								'font-stretch' => 'normal',
+								'font-style'   => 'normal',
+								'font-weight'  => '200',
+							),
+							array(
+								'src'          =>
+									array(
+										'https://example.org/assets/fonts/inter/Inter-VariableFont_slnt-Italic,wght.ttf',
+									),
+								'font-family'  => 'Inter',
+								'font-stretch' => 'normal',
+								'font-style'   => 'italic',
+								'font-weight'  => '900',
+							),
+						),
+				),
+				'expected' => <<<CSS
+@font-face{font-family:Inter;font-style:normal;font-weight:200;font-display:fallback;src:url('https://example.org/assets/fonts/inter/Inter-VariableFont_slnt,wght.ttf') format('truetype');font-stretch:normal;}
+@font-face{font-family:Inter;font-style:italic;font-weight:900;font-display:fallback;src:url('https://example.org/assets/fonts/inter/Inter-VariableFont_slnt-Italic,wght.ttf') format('truetype');font-stretch:normal;}
+CSS
+			,
+			),
+			'single woff2 format font'       => array(
+				'fonts'    => array(
+					'DM Sans' =>
+						array(
+							array(
+								'src'          =>
+									array(
+										'https://example.org/assets/fonts/dm-sans/DMSans-Regular.woff2',
+									),
+								'font-family'  => 'DM Sans',
+								'font-stretch' => 'normal',
+								'font-style'   => 'normal',
+								'font-weight'  => '400',
+							),
+						),
+				),
+				'expected' => <<<CSS
+@font-face{font-family:"DM Sans";font-style:normal;font-weight:400;font-display:fallback;src:url('https://example.org/assets/fonts/dm-sans/DMSans-Regular.woff2') format('woff2');font-stretch:normal;}
+CSS
+			,
+			),
+			'multiple woff2 format fonts'    => array(
+				'fonts'    => array(
+					'DM Sans'       =>
+						array(
+							array(
+								'src'          =>
+									array(
+										'https://example.org/assets/fonts/dm-sans/DMSans-Regular.woff2',
+									),
+								'font-family'  => 'DM Sans',
+								'font-stretch' => 'normal',
+								'font-style'   => 'normal',
+								'font-weight'  => '400',
+							),
+							array(
+								'src'          =>
+									array(
+										'https://example.org/assets/fonts/dm-sans/DMSans-Regular-Italic.woff2',
+									),
+								'font-family'  => 'DM Sans',
+								'font-stretch' => 'normal',
+								'font-style'   => 'italic',
+								'font-weight'  => '400',
+							),
+							array(
+								'src'          =>
+									array(
+										'https://example.org/assets/fonts/dm-sans/DMSans-Bold.woff2',
+									),
+								'font-family'  => 'DM Sans',
+								'font-stretch' => 'normal',
+								'font-style'   => 'normal',
+								'font-weight'  => '700',
+							),
+							array(
+								'src'          =>
+									array(
+										'https://example.org/assets/fonts/dm-sans/DMSans-Bold-Italic.woff2',
+									),
+								'font-family'  => 'DM Sans',
+								'font-stretch' => 'normal',
+								'font-style'   => 'italic',
+								'font-weight'  => '700',
+							),
+						),
+					'IBM Plex Mono' =>
+						array(
+							array(
+								'src'          =>
+									array(
+										'https://example.org/assets/fonts/ibm-plex-mono/IBMPlexMono-Light.woff2',
+									),
+								'font-family'  => 'IBM Plex Mono',
+								'font-display' => 'block',
+								'font-stretch' => 'normal',
+								'font-style'   => 'normal',
+								'font-weight'  => '300',
+							),
+							array(
+								'src'          =>
+									array(
+										'https://example.org/assets/fonts/ibm-plex-mono/IBMPlexMono-Regular.woff2',
+									),
+								'font-family'  => 'IBM Plex Mono',
+								'font-display' => 'block',
+								'font-stretch' => 'normal',
+								'font-style'   => 'normal',
+								'font-weight'  => '400',
+							),
+							array(
+								'src'          =>
+									array(
+										'https://example.org/assets/fonts/ibm-plex-mono/IBMPlexMono-Italic.woff2',
+									),
+								'font-family'  => 'IBM Plex Mono',
+								'font-display' => 'block',
+								'font-stretch' => 'normal',
+								'font-style'   => 'italic',
+								'font-weight'  => '400',
+							),
+							array(
+								'src'          =>
+									array(
+										'https://example.org/assets/fonts/ibm-plex-mono/IBMPlexMono-Bold.woff2',
+									),
+								'font-family'  => 'IBM Plex Mono',
+								'font-display' => 'block',
+								'font-stretch' => 'normal',
+								'font-style'   => 'normal',
+								'font-weight'  => '700',
+							),
+						),
+				),
+				'expected' => <<<CSS
+@font-face{font-family:"DM Sans";font-style:normal;font-weight:400;font-display:fallback;src:url('https://example.org/assets/fonts/dm-sans/DMSans-Regular.woff2') format('woff2');font-stretch:normal;}
+@font-face{font-family:"DM Sans";font-style:italic;font-weight:400;font-display:fallback;src:url('https://example.org/assets/fonts/dm-sans/DMSans-Regular-Italic.woff2') format('woff2');font-stretch:normal;}
+@font-face{font-family:"DM Sans";font-style:normal;font-weight:700;font-display:fallback;src:url('https://example.org/assets/fonts/dm-sans/DMSans-Bold.woff2') format('woff2');font-stretch:normal;}
+@font-face{font-family:"DM Sans";font-style:italic;font-weight:700;font-display:fallback;src:url('https://example.org/assets/fonts/dm-sans/DMSans-Bold-Italic.woff2') format('woff2');font-stretch:normal;}
+@font-face{font-family:"IBM Plex Mono";font-style:normal;font-weight:300;font-display:block;src:url('https://example.org/assets/fonts/ibm-plex-mono/IBMPlexMono-Light.woff2') format('woff2');font-stretch:normal;}
+@font-face{font-family:"IBM Plex Mono";font-style:normal;font-weight:400;font-display:block;src:url('https://example.org/assets/fonts/ibm-plex-mono/IBMPlexMono-Regular.woff2') format('woff2');font-stretch:normal;}
+@font-face{font-family:"IBM Plex Mono";font-style:italic;font-weight:400;font-display:block;src:url('https://example.org/assets/fonts/ibm-plex-mono/IBMPlexMono-Italic.woff2') format('woff2');font-stretch:normal;}
+@font-face{font-family:"IBM Plex Mono";font-style:normal;font-weight:700;font-display:block;src:url('https://example.org/assets/fonts/ibm-plex-mono/IBMPlexMono-Bold.woff2') format('woff2');font-stretch:normal;}
+CSS
+			,
+			),
+		);
+	}
+
+	public function get_expected_fonts_for_fonts_block_theme( $key = '' ) {
+		static $data = null;
+
+		if ( null === $data ) {
+			$uri  = get_stylesheet_directory_uri() . '/assets/fonts/';
+			$data = array(
+				'fonts'            => array(
+					'DM Sans'          => array(
+						array(
+							'src'          => array( $uri . 'dm-sans/DMSans-Regular.woff2' ),
+							'font-family'  => 'DM Sans',
+							'font-stretch' => 'normal',
+							'font-style'   => 'normal',
+							'font-weight'  => '400',
+						),
+						array(
+							'src'          => array( $uri . 'dm-sans/DMSans-Regular-Italic.woff2' ),
+							'font-family'  => 'DM Sans',
+							'font-stretch' => 'normal',
+							'font-style'   => 'italic',
+							'font-weight'  => '400',
+						),
+						array(
+							'src'          => array( $uri . 'dm-sans/DMSans-Bold.woff2' ),
+							'font-family'  => 'DM Sans',
+							'font-stretch' => 'normal',
+							'font-style'   => 'normal',
+							'font-weight'  => '700',
+						),
+						array(
+							'src'          => array( $uri . 'dm-sans/DMSans-Bold-Italic.woff2' ),
+							'font-family'  => 'DM Sans',
+							'font-stretch' => 'normal',
+							'font-style'   => 'italic',
+							'font-weight'  => '700',
+						),
+					),
+					'Source Serif Pro' => array(
+						array(
+							'src'          => array( $uri . 'source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2' ),
+							'font-family'  => 'Source Serif Pro',
+							'font-stretch' => 'normal',
+							'font-style'   => 'normal',
+							'font-weight'  => '200 900',
+						),
+						array(
+							'src'          => array( $uri . 'source-serif-pro/SourceSerif4Variable-Italic.ttf.woff2' ),
+							'font-family'  => 'Source Serif Pro',
+							'font-stretch' => 'normal',
+							'font-style'   => 'italic',
+							'font-weight'  => '200 900',
+						),
+					),
+				),
+				'font_face_styles' => <<<CSS
+@font-face{font-family:"DM Sans";font-style:normal;font-weight:400;font-display:fallback;src:url('{$uri}dm-sans/DMSans-Regular.woff2') format('woff2');font-stretch:normal;}
+@font-face{font-family:"DM Sans";font-style:italic;font-weight:400;font-display:fallback;src:url('{$uri}dm-sans/DMSans-Regular-Italic.woff2') format('woff2');font-stretch:normal;}
+@font-face{font-family:"DM Sans";font-style:normal;font-weight:700;font-display:fallback;src:url('{$uri}dm-sans/DMSans-Bold.woff2') format('woff2');font-stretch:normal;}
+@font-face{font-family:"DM Sans";font-style:italic;font-weight:700;font-display:fallback;src:url('{$uri}dm-sans/DMSans-Bold-Italic.woff2') format('woff2');font-stretch:normal;}
+@font-face{font-family:"Source Serif Pro";font-style:normal;font-weight:200 900;font-display:fallback;src:url('{$uri}source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2') format('woff2');font-stretch:normal;}
+@font-face{font-family:"Source Serif Pro";font-style:italic;font-weight:200 900;font-display:fallback;src:url('{$uri}source-serif-pro/SourceSerif4Variable-Italic.ttf.woff2') format('woff2');font-stretch:normal;}
+CSS
+				,
+			);
+		}
+
+		if ( isset( $data[ $key ] ) ) {
+			return $data[ $key ];
+		}
+
+		return $data;
+	}
+}
diff --git a/phpunit/fonts/wpFontFace/generateAndPrint-test.php b/phpunit/fonts/wpFontFace/generateAndPrint-test.php
new file mode 100644
index 0000000000000..302395d8fead6
--- /dev/null
+++ b/phpunit/fonts/wpFontFace/generateAndPrint-test.php
@@ -0,0 +1,57 @@
+<?php
+/**
+ * Test case for WP_Font_Face::generate_and_print().
+ *
+ * @package    WordPress
+ * @subpackage Fonts
+ */
+
+require_once __DIR__ . '/../wp-font-face-tests-dataset.php';
+
+/*
+ * This code is only needed if the Font API is enabled.
+ * @todo remove this code when Font Library is merged into Gutenberg.
+ */
+if ( ! class_exists( 'WP_Font_Face' ) ) {
+	require_once __DIR__ . '/../../../lib/experimental/fonts/class-wp-font-face.php';
+	require_once __DIR__ . '/../../../lib/experimental/fonts/class-wp-font-face-resolver.php';
+	require_once __DIR__ . '/../../../lib/experimental/fonts/fonts.php';
+}
+
+/**
+ * Test WP_Font_Face::generate_and_print().
+ *
+ * @package WordPress
+ * @subpackage Fonts
+ *
+ * @since X.X.X
+ * @group fonts
+ * @group fontface
+ * @covers WP_Font_Face::generate_and_print
+ */
+class Tests_Fonts_WPFontFace_GenerateAndPrint extends WP_UnitTestCase {
+	use WP_Font_Face_Tests_Datasets;
+
+	public function test_should_not_generate_and_print_when_no_fonts() {
+		$font_face = new WP_Font_Face();
+		$fonts     = array();
+
+		$this->expectOutputString( '' );
+		$font_face->generate_and_print( $fonts );
+	}
+
+	/**
+	 * @dataProvider data_should_print_given_fonts
+	 *
+	 * @param array  $fonts Prepared fonts.
+	 * @param string $expected Expected CSS.
+	 */
+	public function test_should_generate_and_print_given_fonts( array $fonts, $expected ) {
+		$font_face       = new WP_Font_Face();
+		$style_element   = "<style id='wp-fonts-local' type='text/css'>\n%s\n</style>\n";
+		$expected_output = sprintf( $style_element, $expected );
+
+		$this->expectOutputString( $expected_output );
+		$font_face->generate_and_print( $fonts );
+	}
+}
diff --git a/phpunit/fonts/wpFontFaceResolver/getFontsFromThemeJson-test.php b/phpunit/fonts/wpFontFaceResolver/getFontsFromThemeJson-test.php
new file mode 100644
index 0000000000000..74c0f0a4f3c42
--- /dev/null
+++ b/phpunit/fonts/wpFontFaceResolver/getFontsFromThemeJson-test.php
@@ -0,0 +1,116 @@
+<?php
+/**
+ * Test case for WP_Font_Face_Resolver::get_fonts_from_theme_json().
+ *
+ * @package    WordPress
+ * @subpackage Fonts
+ */
+
+require_once __DIR__ . '/../wp-font-face-testcase.php';
+
+/*
+ * This code is only needed if the Font API is enabled.
+ * @todo remove this code when Font Library is merged into Gutenberg.
+ */
+if ( ! class_exists( 'WP_Font_Face' ) ) {
+	require_once __DIR__ . '/../../../lib/experimental/fonts/class-wp-font-face.php';
+	require_once __DIR__ . '/../../../lib/experimental/fonts/class-wp-font-face-resolver.php';
+	require_once __DIR__ . '/../../../lib/experimental/fonts/fonts.php';
+}
+
+/**
+ * Tests WP_Font_Face_Resolver::get_fonts_from_theme_json().
+ *
+ * @package WordPress
+ * @subpackage Fonts
+ *
+ * @since X.X.X
+ * @group fonts
+ * @group fontface
+ * @covers WP_Font_Face_Resolver::get_fonts_from_theme_json
+ */
+class Tests_Fonts_WPFontFaceResolver_GetFontsFromThemeJson extends WP_Font_Face_TestCase {
+	const FONTS_THEME = 'fonts-block-theme';
+
+	public static function set_up_before_class() {
+		self::$requires_switch_theme_fixtures = true;
+
+		parent::set_up_before_class();
+	}
+
+	public function test_should_return_empty_array_when_no_fonts_defined_in_theme() {
+		switch_theme( 'block-theme' );
+
+		$fonts = WP_Font_Face_Resolver::get_fonts_from_theme_json();
+		$this->assertIsArray( $fonts, 'Should return an array data type' );
+		$this->assertEmpty( $fonts, 'Should return an empty array' );
+	}
+
+	public function test_should_return_all_fonts_from_theme() {
+		switch_theme( static::FONTS_THEME );
+
+		$actual   = WP_Font_Face_Resolver::get_fonts_from_theme_json();
+		$expected = $this->get_expected_fonts_for_fonts_block_theme( 'fonts' );
+		$this->assertSame( $expected, $actual );
+	}
+
+	/**
+	 * @dataProvider data_should_replace_src_file_placeholder
+	 *
+	 * @param string $font_name  Font's name.
+	 * @param string $font_index Font's index in the $fonts array.
+	 * @param string $expected   Expected src.
+	 */
+	public function test_should_replace_src_file_placeholder( $font_name, $font_index, $expected ) {
+		switch_theme( static::FONTS_THEME );
+
+		$fonts = WP_Font_Face_Resolver::get_fonts_from_theme_json();
+
+		$actual   = $fonts[ $font_name ][ $font_index ]['src'][0];
+		$expected = get_stylesheet_directory_uri() . $expected;
+
+		$this->assertStringNotContainsString( 'file:./', $actual, 'Font src should not contain the "file:./" placeholder' );
+		$this->assertSame( $expected, $actual, 'Font src should be an URL to its file' );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public function data_should_replace_src_file_placeholder() {
+		return array(
+			// Theme's theme.json.
+			'DM Sans: 400 normal'              => array(
+				'font_name'  => 'DM Sans',
+				'font_index' => 0,
+				'expected'   => '/assets/fonts/dm-sans/DMSans-Regular.woff2',
+			),
+			'DM Sans: 400 italic'              => array(
+				'font_name'  => 'DM Sans',
+				'font_index' => 1,
+				'expected'   => '/assets/fonts/dm-sans/DMSans-Regular-Italic.woff2',
+			),
+			'DM Sans: 700 normal'              => array(
+				'font_name'  => 'DM Sans',
+				'font_index' => 2,
+				'expected'   => '/assets/fonts/dm-sans/DMSans-Bold.woff2',
+			),
+			'DM Sans: 700 italic'              => array(
+				'font_name'  => 'DM Sans',
+				'font_index' => 3,
+				'expected'   => '/assets/fonts/dm-sans/DMSans-Bold-Italic.woff2',
+			),
+			'Source Serif Pro: 200-900 normal' => array(
+				'font_name'  => 'Source Serif Pro',
+				'font_index' => 0,
+				'expected'   => '/assets/fonts/source-serif-pro/SourceSerif4Variable-Roman.ttf.woff2',
+			),
+			'Source Serif Pro: 200-900 italic' => array(
+				'font_name'  => 'Source Serif Pro',
+				'font_index' => 1,
+				'expected'   => '/assets/fonts/source-serif-pro/SourceSerif4Variable-Italic.ttf.woff2',
+			),
+		);
+	}
+}
diff --git a/phpunit/fonts/wpPrintFontFaces-test.php b/phpunit/fonts/wpPrintFontFaces-test.php
new file mode 100644
index 0000000000000..aa44dd4f71b0d
--- /dev/null
+++ b/phpunit/fonts/wpPrintFontFaces-test.php
@@ -0,0 +1,75 @@
+<?php
+/**
+ * Test case for wp_print_font_faces().
+ *
+ * @package    WordPress
+ * @subpackage Fonts
+ */
+
+require_once __DIR__ . '/wp-font-face-testcase.php';
+
+/*
+ * This code is only needed if the Font API is enabled.
+ * @todo remove this code when Font Library is merged into Gutenberg.
+ */
+if ( ! class_exists( 'WP_Font_Face' ) ) {
+	require_once __DIR__ . '/../../../lib/experimental/fonts/class-wp-font-face.php';
+	require_once __DIR__ . '/../../../lib/experimental/fonts/class-wp-font-face-resolver.php';
+	require_once __DIR__ . '/../../../lib/experimental/fonts/fonts.php';
+}
+
+/**
+ * Test wp_print_font_faces().
+ *
+ * @package WordPress
+ * @subpackage Fonts
+ *
+ * @since X.X.X
+ * @group fonts
+ * @group fontface
+ * @covers wp_print_font_faces
+ */
+class Tests_Fonts_WPPrintFontFaces extends WP_Font_Face_TestCase {
+	const FONTS_THEME = 'fonts-block-theme';
+
+	public static function set_up_before_class() {
+		self::$requires_switch_theme_fixtures = true;
+
+		parent::set_up_before_class();
+	}
+
+	public function test_should_not_print_when_no_fonts() {
+		switch_theme( 'block-theme' );
+
+		$this->expectOutputString( '' );
+		wp_print_font_faces();
+	}
+
+	/**
+	 * @dataProvider data_should_print_given_fonts
+	 *
+	 * @param array  $fonts    Fonts to process.
+	 * @param string $expected Expected CSS.
+	 */
+	public function test_should_print_given_fonts( array $fonts, $expected ) {
+		$expected_output = $this->get_expected_styles_output( $expected );
+
+		$this->expectOutputString( $expected_output );
+		wp_print_font_faces( $fonts );
+	}
+
+	public function test_should_print_fonts_in_merged_data() {
+		switch_theme( static::FONTS_THEME );
+
+		$expected        = $this->get_expected_fonts_for_fonts_block_theme( 'font_face_styles' );
+		$expected_output = $this->get_expected_styles_output( $expected );
+
+		$this->expectOutputString( $expected_output );
+		wp_print_font_faces();
+	}
+
+	private function get_expected_styles_output( $styles ) {
+		$style_element = "<style id='wp-fonts-local' type='text/css'>\n%s\n</style>\n";
+		return sprintf( $style_element, $styles );
+	}
+}