chore: add-harness-tests

Author: riteshshukla04

example/.harness/manifest.js

@@ -1,4 +1,4 @@
-global.RN_HARNESS = { 
-    appRegistryComponentName: 'NitroImageExample',
-    disableViewFlattening: false,
-  };
+global.RN_HARNESS = {
+  appRegistryComponentName: 'NitroImageExample',
+  disableViewFlattening: false,
+}

example/__tests__/image-encoding.harness.ts

@@ -1,59 +1,59 @@
-import { describe, it, expect } from 'react-native-harness';
-import { Images } from 'react-native-nitro-image';
+import { describe, expect, it } from 'react-native-harness'
+import { Images } from 'react-native-nitro-image'
 
 const makeImage = () =>
-  Images.createBlankImage(16, 16, false, { r: 0, g: 0, b: 1, a: 1 });
+  Images.createBlankImage(16, 16, false, { r: 0, g: 0, b: 1, a: 1 })
 
 describe('Image - toRawPixelData', () => {
   it('returns a non-empty pixel buffer with matching dimensions', () => {
-    const image = makeImage();
-    const raw = image.toRawPixelData();
-    expect(raw.width).toBe(16);
-    expect(raw.height).toBe(16);
-    expect(raw.buffer.byteLength).toBeGreaterThan(0);
-    expect(typeof raw.pixelFormat).toBe('string');
-  });
+    const image = makeImage()
+    const raw = image.toRawPixelData()
+    expect(raw.width).toBe(16)
+    expect(raw.height).toBe(16)
+    expect(raw.buffer.byteLength).toBeGreaterThan(0)
+    expect(typeof raw.pixelFormat).toBe('string')
+  })
 
   it('toRawPixelDataAsync resolves with pixel data', async () => {
-    const image = makeImage();
-    const raw = await image.toRawPixelDataAsync();
-    expect(raw.buffer.byteLength).toBeGreaterThan(0);
-  });
-});
+    const image = makeImage()
+    const raw = await image.toRawPixelDataAsync()
+    expect(raw.buffer.byteLength).toBeGreaterThan(0)
+  })
+})
 
 describe('Image - toEncodedImageData', () => {
   it('encodes to PNG', () => {
-    const image = makeImage();
-    const encoded = image.toEncodedImageData('png');
-    expect(encoded.imageFormat).toBe('png');
-    expect(encoded.width).toBe(16);
-    expect(encoded.height).toBe(16);
-    expect(encoded.buffer.byteLength).toBeGreaterThan(0);
-  });
+    const image = makeImage()
+    const encoded = image.toEncodedImageData('png')
+    expect(encoded.imageFormat).toBe('png')
+    expect(encoded.width).toBe(16)
+    expect(encoded.height).toBe(16)
+    expect(encoded.buffer.byteLength).toBeGreaterThan(0)
+  })
 
   it('encodes to JPEG with quality', async () => {
-    const image = makeImage();
-    const encoded = await image.toEncodedImageDataAsync('jpg', 70);
-    expect(encoded.imageFormat).toBe('jpg');
-    expect(encoded.buffer.byteLength).toBeGreaterThan(0);
-  });
-});
+    const image = makeImage()
+    const encoded = await image.toEncodedImageDataAsync('jpg', 70)
+    expect(encoded.imageFormat).toBe('jpg')
+    expect(encoded.buffer.byteLength).toBeGreaterThan(0)
+  })
+})
 
 describe('Images - loadFromEncodedImageData', () => {
   it('round-trips through PNG encoding', () => {
-    const image = makeImage();
-    const encoded = image.toEncodedImageData('png');
-    const decoded = Images.loadFromEncodedImageData(encoded);
-    expect(decoded.width).toBe(image.width);
-    expect(decoded.height).toBe(image.height);
-  });
-});
+    const image = makeImage()
+    const encoded = image.toEncodedImageData('png')
+    const decoded = Images.loadFromEncodedImageData(encoded)
+    expect(decoded.width).toBe(image.width)
+    expect(decoded.height).toBe(image.height)
+  })
+})
 
 describe('Image - saveToTemporaryFileAsync', () => {
   it('writes a JPG to a temporary path', async () => {
-    const image = makeImage();
-    const path = await image.saveToTemporaryFileAsync('jpg', 80);
-    expect(typeof path).toBe('string');
-    expect(path.length).toBeGreaterThan(0);
-  });
-});
+    const image = makeImage()
+    const path = await image.saveToTemporaryFileAsync('jpg', 80)
+    expect(typeof path).toBe('string')
+    expect(path.length).toBeGreaterThan(0)
+  })
+})

example/__tests__/image-transforms.harness.ts

@@ -1,55 +1,55 @@
-import { describe, it, expect } from 'react-native-harness';
-import { Images } from 'react-native-nitro-image';
+import { describe, expect, it } from 'react-native-harness'
+import { Images } from 'react-native-nitro-image'
 
 const makeImage = (w = 32, h = 32) =>
-  Images.createBlankImage(w, h, true, { r: 0, g: 1, b: 0, a: 1 });
+  Images.createBlankImage(w, h, true, { r: 0, g: 1, b: 0, a: 1 })
 
 describe('Image - resize', () => {
   it('resizes synchronously to the requested dimensions', () => {
-    const image = makeImage(40, 20);
-    const resized = image.resize(20, 10);
-    expect(resized.width).toBe(20);
-    expect(resized.height).toBe(10);
-  });
+    const image = makeImage(40, 20)
+    const resized = image.resize(20, 10)
+    expect(resized.width).toBe(20)
+    expect(resized.height).toBe(10)
+  })
 
   it('resizes asynchronously to the requested dimensions', async () => {
-    const image = makeImage(40, 20);
-    const resized = await image.resizeAsync(80, 40);
-    expect(resized.width).toBe(80);
-    expect(resized.height).toBe(40);
-  });
-});
+    const image = makeImage(40, 20)
+    const resized = await image.resizeAsync(80, 40)
+    expect(resized.width).toBe(80)
+    expect(resized.height).toBe(40)
+  })
+})
 
 describe('Image - crop', () => {
   it('crops to a sub-region', () => {
-    const image = makeImage(100, 100);
-    const cropped = image.crop(10, 10, 50, 50);
-    expect(cropped.width).toBe(40);
-    expect(cropped.height).toBe(40);
-  });
-});
+    const image = makeImage(100, 100)
+    const cropped = image.crop(10, 10, 50, 50)
+    expect(cropped.width).toBe(40)
+    expect(cropped.height).toBe(40)
+  })
+})
 
 describe('Image - rotate', () => {
   it('rotates 90 degrees and returns an Image', () => {
-    const image = makeImage(40, 20);
-    const rotated = image.rotate(90);
-    expect(rotated.width).toBeGreaterThan(0);
-    expect(rotated.height).toBeGreaterThan(0);
-  });
+    const image = makeImage(40, 20)
+    const rotated = image.rotate(90)
+    expect(rotated.width).toBeGreaterThan(0)
+    expect(rotated.height).toBeGreaterThan(0)
+  })
 
   it('rotates 180 degrees and preserves dimensions', () => {
-    const image = makeImage(40, 20);
-    const rotated = image.rotate(180);
-    expect(rotated.width).toBe(40);
-    expect(rotated.height).toBe(20);
-  });
-});
+    const image = makeImage(40, 20)
+    const rotated = image.rotate(180)
+    expect(rotated.width).toBe(40)
+    expect(rotated.height).toBe(20)
+  })
+})
 
 describe('Image - mirrorHorizontally', () => {
   it('preserves dimensions when mirroring', () => {
-    const image = makeImage(30, 20);
-    const mirrored = image.mirrorHorizontally();
-    expect(mirrored.width).toBe(30);
-    expect(mirrored.height).toBe(20);
-  });
-});
+    const image = makeImage(30, 20)
+    const mirrored = image.mirrorHorizontally()
+    expect(mirrored.width).toBe(30)
+    expect(mirrored.height).toBe(20)
+  })
+})

example/__tests__/image-utils.harness.ts

@@ -1,18 +1,18 @@
-import { describe, it, expect } from 'react-native-harness';
+import { describe, expect, it } from 'react-native-harness'
 import {
   Images,
   supportsHeicLoading,
   supportsHeicWriting,
-  thumbHashToBase64String,
   thumbHashFromBase64String,
-} from 'react-native-nitro-image';
+  thumbHashToBase64String,
+} from 'react-native-nitro-image'
 
 describe('ImageUtils - HEIC support flags', () => {
   it('exposes booleans for HEIC loading and writing', () => {
-    expect(typeof supportsHeicLoading).toBe('boolean');
-    expect(typeof supportsHeicWriting).toBe('boolean');
-  });
-});
+    expect(typeof supportsHeicLoading).toBe('boolean')
+    expect(typeof supportsHeicWriting).toBe('boolean')
+  })
+})
 
 describe('ImageUtils - thumbHash round-trip', () => {
   it('encodes a small image to a thumbHash and converts to base64', () => {
@@ -21,29 +21,29 @@ describe('ImageUtils - thumbHash round-trip', () => {
       g: 0.2,
       b: 0.8,
       a: 1,
-    });
-    const small = image.resize(32, 32);
-    const hash = small.toThumbHash();
-    expect(hash.byteLength).toBeGreaterThan(0);
+    })
+    const small = image.resize(32, 32)
+    const hash = small.toThumbHash()
+    expect(hash.byteLength).toBeGreaterThan(0)
 
-    const base64 = thumbHashToBase64String(hash);
-    expect(typeof base64).toBe('string');
-    expect(base64.length).toBeGreaterThan(0);
+    const base64 = thumbHashToBase64String(hash)
+    expect(typeof base64).toBe('string')
+    expect(base64.length).toBeGreaterThan(0)
 
-    const restored = thumbHashFromBase64String(base64);
-    expect(restored.byteLength).toBe(hash.byteLength);
-  });
+    const restored = thumbHashFromBase64String(base64)
+    expect(restored.byteLength).toBe(hash.byteLength)
+  })
 
   it('decodes thumbHash bytes back into an Image', () => {
     const image = Images.createBlankImage(32, 32, true, {
       r: 1,
       g: 0,
       b: 0,
       a: 1,
-    });
-    const hash = image.toThumbHash();
-    const decoded = Images.loadFromThumbHash(hash);
-    expect(decoded.width).toBeGreaterThan(0);
-    expect(decoded.height).toBeGreaterThan(0);
-  });
-});
+    })
+    const hash = image.toThumbHash()
+    const decoded = Images.loadFromThumbHash(hash)
+    expect(decoded.width).toBeGreaterThan(0)
+    expect(decoded.height).toBeGreaterThan(0)
+  })
+})

example/__tests__/images.harness.ts

@@ -1,37 +1,37 @@
-import { describe, it, expect } from 'react-native-harness';
-import { Images } from 'react-native-nitro-image';
+import { describe, expect, it } from 'react-native-harness'
+import { Images } from 'react-native-nitro-image'
 
 describe('Images - createBlankImage', () => {
   it('creates a blank image with the requested dimensions', () => {
-    const image = Images.createBlankImage(64, 32, false);
-    expect(image.width).toBe(64);
-    expect(image.height).toBe(32);
-  });
+    const image = Images.createBlankImage(64, 32, false)
+    expect(image.width).toBe(64)
+    expect(image.height).toBe(32)
+  })
 
   it('creates a blank image with alpha enabled', () => {
-    const image = Images.createBlankImage(16, 16, true);
-    expect(image.width).toBe(16);
-    expect(image.height).toBe(16);
-  });
+    const image = Images.createBlankImage(16, 16, true)
+    expect(image.width).toBe(16)
+    expect(image.height).toBe(16)
+  })
 
   it('fills the image with a solid color when fill is provided', () => {
     const image = Images.createBlankImage(8, 8, true, {
       r: 1,
       g: 0,
       b: 0,
       a: 1,
-    });
-    const raw = image.toRawPixelData();
-    expect(raw.width).toBe(8);
-    expect(raw.height).toBe(8);
-    expect(raw.buffer.byteLength).toBeGreaterThan(0);
-  });
-});
+    })
+    const raw = image.toRawPixelData()
+    expect(raw.width).toBe(8)
+    expect(raw.height).toBe(8)
+    expect(raw.buffer.byteLength).toBeGreaterThan(0)
+  })
+})
 
 describe('Images - createBlankImageAsync', () => {
   it('resolves with an Image of the requested size', async () => {
-    const image = await Images.createBlankImageAsync(20, 10, false);
-    expect(image.width).toBe(20);
-    expect(image.height).toBe(10);
-  });
-});
+    const image = await Images.createBlankImageAsync(20, 10, false)
+    expect(image.width).toBe(20)
+    expect(image.height).toBe(10)
+  })
+})