@typescriptify/sweph 1.0.0

package/tests/c-style/crossings.test.ts

@@ -0,0 +1,81 @@
+import { describe, it, before, after } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { near, J2000 } from '../helpers';
+import { createDefaultSweData } from '../../src/types';
+import { julDay, revJul } from '../../src/swedate';
+import {
+  sweSolcross, sweSolcrossUt,
+  sweMooncross, sweMooncrossUt,
+  sweMooncrossNode, sweMooncrossNodeUt,
+  sweHelioCross, sweHelioCrossUt,
+  sweClose,
+} from '../../src/sweph';
+import { SE_MARS, SEFLG_MOSEPH, SE_GREG_CAL } from '../../src/constants';
+
+describe('Crossings (C-style)', () => {
+  let swed: ReturnType<typeof createDefaultSweData>;
+
+  before(() => { swed = createDefaultSweData(); });
+  after(() => { sweClose(swed); });
+
+  describe('sweSolcross (vernal equinox 2000)', () => {
+    it('should find equinox on Mar 20', () => {
+      const start = julDay(2000, 3, 1, 0, SE_GREG_CAL);
+      const r = sweSolcross(swed, 0, start, SEFLG_MOSEPH);
+      assert.ok(r.jd > start);
+      const d = revJul(r.jd, SE_GREG_CAL);
+      assert.strictEqual(d.month, 3);
+      assert.strictEqual(d.day, 20);
+    });
+  });
+
+  describe('sweSolcrossUt', () => {
+    it('should find equinox after start', () => {
+      const start = julDay(2000, 3, 1, 0, SE_GREG_CAL);
+      const r = sweSolcrossUt(swed, 0, start, SEFLG_MOSEPH);
+      assert.ok(r.jd > start);
+    });
+  });
+
+  describe('sweMooncross', () => {
+    it('should find Moon crossing 0 deg', () => {
+      const r = sweMooncross(swed, 0, J2000, SEFLG_MOSEPH);
+      assert.ok(r.jd > 0);
+    });
+  });
+
+  describe('sweMooncrossUt', () => {
+    it('should find Moon crossing 0 deg (UT)', () => {
+      const r = sweMooncrossUt(swed, 0, J2000, SEFLG_MOSEPH);
+      assert.ok(r.jd > 0);
+    });
+  });
+
+  describe('sweMooncrossNode', () => {
+    it('should find next node crossing', () => {
+      const r = sweMooncrossNode(swed, J2000, SEFLG_MOSEPH);
+      assert.ok(r.jd > 0);
+    });
+  });
+
+  describe('sweMooncrossNodeUt', () => {
+    it('should find next node crossing (UT)', () => {
+      const r = sweMooncrossNodeUt(swed, J2000, SEFLG_MOSEPH);
+      assert.ok(r.jd > 0);
+    });
+  });
+
+  describe('sweHelioCross', () => {
+    it('Mars helio cross should succeed', () => {
+      const r = sweHelioCross(swed, SE_MARS, 0, J2000, SEFLG_MOSEPH, 1);
+      assert.ok(r.retval >= 0);
+    });
+  });
+
+  describe('sweHelioCrossUt', () => {
+    it('Mars helio cross UT should succeed', () => {
+      const r = sweHelioCrossUt(swed, SE_MARS, 0, J2000, SEFLG_MOSEPH, 1);
+      assert.ok(r.retval >= 0);
+    });
+  });
+});

package/tests/c-style/date-time.test.ts

@@ -0,0 +1,114 @@
+import { describe, it } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { near, J2000 } from '../helpers';
+import { createDefaultSweData } from '../../src/types';
+import { julDay, revJul, dateConversion, utcTimeZone, utcToJd, jdetToUtc, jdut1ToUtc } from '../../src/swedate';
+import { sweDeltat, sweDeltatEx, sweSidtime, sweSidtime0, sweDayOfWeek } from '../../src/swephlib';
+import { SE_GREG_CAL, SE_JUL_CAL, SEFLG_MOSEPH } from '../../src/constants';
+
+const swed = createDefaultSweData();
+const deltatFn = (tjd: number, iflag: number) => sweDeltatEx(tjd, iflag, swed);
+
+describe('Date/Time (C-style)', () => {
+  describe('julDay / revJul', () => {
+    it('should return J2000 = 2451545.0', () => {
+      assert.strictEqual(julDay(2000, 1, 1, 12, SE_GREG_CAL), J2000);
+    });
+
+    it('should round-trip through revJul', () => {
+      const rv = revJul(J2000, SE_GREG_CAL);
+      assert.strictEqual(rv.year, 2000);
+      assert.strictEqual(rv.month, 1);
+      assert.strictEqual(rv.day, 1);
+      assert.strictEqual(rv.hour, 12);
+    });
+
+    it('should handle Julian calendar', () => {
+      const jd = julDay(2000, 1, 1, 12, SE_JUL_CAL);
+      assert.ok(jd !== J2000, 'Julian and Gregorian should differ');
+      const rv = revJul(jd, SE_JUL_CAL);
+      assert.strictEqual(rv.year, 2000);
+      assert.strictEqual(rv.month, 1);
+      assert.strictEqual(rv.day, 1);
+    });
+
+    it('should handle negative years (BCE)', () => {
+      const jd = julDay(-4712, 1, 1, 12, SE_JUL_CAL);
+      assert.ok(jd >= 0 && jd < 1, `JD epoch should be near 0, got ${jd}`);
+    });
+  });
+
+  describe('dateConversion', () => {
+    it('should validate a valid Gregorian date', () => {
+      const dc = dateConversion(2000, 1, 1, 12, 'g');
+      assert.ok(dc.ok);
+      near(dc.jd, J2000, 0.001);
+    });
+  });
+
+  describe('utcTimeZone', () => {
+    it('should offset by timezone', () => {
+      const tz = utcTimeZone(2000, 1, 1, 12, 0, 0, -5);
+      assert.strictEqual(tz.hour, 17);
+    });
+  });
+
+  describe('utcToJd / jdetToUtc / jdut1ToUtc', () => {
+    it('should convert UTC to JD', () => {
+      const r = utcToJd(2000, 1, 1, 12, 0, 0, SE_GREG_CAL, deltatFn);
+      near(r.tjdUt, J2000, 0.001);
+      assert.ok(r.tjdEt > r.tjdUt, 'ET should be ahead of UT');
+    });
+
+    it('should round-trip through jdetToUtc', () => {
+      const r = utcToJd(2000, 1, 1, 12, 0, 0, SE_GREG_CAL, deltatFn);
+      const utc = jdetToUtc(r.tjdEt, SE_GREG_CAL, deltatFn);
+      assert.strictEqual(utc.year, 2000);
+      assert.strictEqual(utc.month, 1);
+      assert.strictEqual(utc.day, 1);
+    });
+
+    it('should round-trip through jdut1ToUtc', () => {
+      const r = utcToJd(2000, 1, 1, 12, 0, 0, SE_GREG_CAL, deltatFn);
+      const utc = jdut1ToUtc(r.tjdUt, SE_GREG_CAL, deltatFn);
+      assert.strictEqual(utc.year, 2000);
+    });
+  });
+
+  describe('deltaT', () => {
+    it('should return positive value at J2000', () => {
+      const dt = sweDeltat(J2000, swed);
+      assert.ok(dt > 0, `deltaT should be > 0, got ${dt}`);
+      assert.ok(dt < 0.01, `deltaT should be < 0.01 days, got ${dt}`);
+    });
+
+    it('should match sweDeltatEx', () => {
+      const dt = sweDeltat(J2000, swed);
+      const dtEx = sweDeltatEx(J2000, SEFLG_MOSEPH, swed);
+      near(dt, dtEx, 0.0001);
+    });
+  });
+
+  describe('sidereal time', () => {
+    it('sweSidtime should return 0-24 hours', () => {
+      const st = sweSidtime(swed, J2000);
+      assert.ok(st > 0 && st < 24, `sidtime=${st}`);
+    });
+
+    it('sweSidtime0 should return 0-24 hours', () => {
+      const st = sweSidtime0(swed, J2000, 23.44, 0);
+      assert.ok(st > 0 && st < 24);
+    });
+  });
+
+  describe('dayOfWeek', () => {
+    it('J2000 should be Saturday (5)', () => {
+      assert.strictEqual(sweDayOfWeek(J2000), 5);
+    });
+
+    it('2024-01-01 should be Monday (0)', () => {
+      const jd = julDay(2024, 1, 1, 12, SE_GREG_CAL);
+      assert.strictEqual(sweDayOfWeek(jd), 0);
+    });
+  });
+});

package/tests/c-style/eclipses.test.ts

@@ -0,0 +1,84 @@
+import { describe, it, before, after } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { near, J2000 } from '../helpers';
+import { createDefaultSweData } from '../../src/types';
+import { sweClose } from '../../src/sweph';
+import { julDay, revJul } from '../../src/swedate';
+import {
+  sweSolEclipseWhenGlob, sweSolEclipseWhere, sweSolEclipseHow, sweSolEclipseWhenLoc,
+  sweLunEclipseWhen, sweLunEclipseHow, sweLunEclipseWhenLoc,
+  sweLunOccultWhenGlob,
+} from '../../src/swecl';
+import { SE_MARS, SEFLG_MOSEPH, SE_GREG_CAL } from '../../src/constants';
+
+describe('Eclipses (C-style)', () => {
+  let swed: ReturnType<typeof createDefaultSweData>;
+
+  before(() => { swed = createDefaultSweData(); });
+  after(() => { sweClose(swed); });
+
+  describe('Solar eclipse — 2024 Apr 8 total', () => {
+    it('should find the eclipse', () => {
+      const start = julDay(2024, 3, 1, 0, SE_GREG_CAL);
+      const r = sweSolEclipseWhenGlob(swed, start, SEFLG_MOSEPH, 0, 0);
+      assert.ok(r.retval > 0, `retval=${r.retval}`);
+      const d = revJul(r.tret[0], SE_GREG_CAL);
+      assert.strictEqual(d.month, 4);
+      assert.strictEqual(d.day, 8);
+    });
+
+    it('should locate central path near lon -104', () => {
+      const start = julDay(2024, 3, 1, 0, SE_GREG_CAL);
+      const ecl = sweSolEclipseWhenGlob(swed, start, SEFLG_MOSEPH, 0, 0);
+      const where = sweSolEclipseWhere(swed, ecl.tret[0], SEFLG_MOSEPH);
+      assert.ok(where.retval > 0);
+      near(where.geopos[0], -104, 20);
+    });
+
+    it('sweSolEclipseHow should return valid attributes', () => {
+      const start = julDay(2024, 3, 1, 0, SE_GREG_CAL);
+      const ecl = sweSolEclipseWhenGlob(swed, start, SEFLG_MOSEPH, 0, 0);
+      const how = sweSolEclipseHow(swed, ecl.tret[0], SEFLG_MOSEPH, [-104, 25, 0]);
+      assert.ok(how.retval >= 0);
+    });
+
+    it('sweSolEclipseWhenLoc should find local eclipse', () => {
+      const start = julDay(2024, 3, 1, 0, SE_GREG_CAL);
+      const r = sweSolEclipseWhenLoc(swed, start, SEFLG_MOSEPH, [-104, 25, 0], 0);
+      assert.ok(r.retval > 0);
+    });
+  });
+
+  describe('Lunar eclipse — 2025 Mar 14 total', () => {
+    it('should find the eclipse', () => {
+      const start = julDay(2025, 3, 1, 0, SE_GREG_CAL);
+      const r = sweLunEclipseWhen(swed, start, SEFLG_MOSEPH, 0, 0);
+      assert.ok(r.retval > 0);
+      const d = revJul(r.tret[0], SE_GREG_CAL);
+      assert.strictEqual(d.month, 3);
+      assert.strictEqual(d.day, 14);
+    });
+
+    it('should have umbral magnitude ~1.176', () => {
+      const start = julDay(2025, 3, 1, 0, SE_GREG_CAL);
+      const ecl = sweLunEclipseWhen(swed, start, SEFLG_MOSEPH, 0, 0);
+      const how = sweLunEclipseHow(swed, ecl.tret[0], SEFLG_MOSEPH, null);
+      assert.ok(how.retval > 0);
+      near(how.attr[0], 1.176, 0.05);
+    });
+
+    it('sweLunEclipseWhenLoc should return', () => {
+      const start = julDay(2025, 3, 1, 0, SE_GREG_CAL);
+      const r = sweLunEclipseWhenLoc(swed, start, SEFLG_MOSEPH, [-0.1278, 51.5074, 0], 0);
+      assert.ok(typeof r.retval === 'number');
+    });
+  });
+
+  describe('Occultation', () => {
+    it('should search for Mars occultation without error', () => {
+      const start = julDay(2024, 1, 1, 0, SE_GREG_CAL);
+      const r = sweLunOccultWhenGlob(swed, start, SE_MARS, null, SEFLG_MOSEPH, 0, 0);
+      assert.ok(typeof r.retval === 'number');
+    });
+  });
+});

package/tests/c-style/fixed-stars.test.ts

@@ -0,0 +1,66 @@
+import { describe, it, before, after } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { near, J2000 } from '../helpers';
+import { createDefaultSweData } from '../../src/types';
+import {
+  sweFixstar, sweFixstarUt, sweFixstarMag,
+  sweFixstar2, sweFixstar2Ut, sweFixstar2Mag, sweClose,
+} from '../../src/sweph';
+import { SEFLG_MOSEPH } from '../../src/constants';
+
+describe('Fixed Stars (C-style)', () => {
+  let swed: ReturnType<typeof createDefaultSweData>;
+
+  before(() => { swed = createDefaultSweData(); });
+  after(() => { sweClose(swed); });
+
+  describe('sweFixstar', () => {
+    it('Spica should have longitude ~203.84 at J2000', () => {
+      const r = sweFixstar(swed, 'Spica', J2000, SEFLG_MOSEPH);
+      near(r.xx[0], 203.84, 0.2);
+    });
+
+    it('should return canonical star name', () => {
+      const r = sweFixstar(swed, 'Spica', J2000, SEFLG_MOSEPH);
+      assert.ok(r.starOut.includes('Spica'), `starOut=${r.starOut}`);
+    });
+  });
+
+  describe('sweFixstarUt', () => {
+    it('should produce position close to ET variant', () => {
+      const et = sweFixstar(swed, 'Spica', J2000, SEFLG_MOSEPH);
+      const ut = sweFixstarUt(swed, 'Spica', J2000, SEFLG_MOSEPH);
+      near(ut.xx[0], et.xx[0], 0.01);
+    });
+  });
+
+  describe('sweFixstarMag', () => {
+    it('Spica should have magnitude ~0.98', () => {
+      const r = sweFixstarMag(swed, 'Spica');
+      assert.ok(r.mag !== undefined, 'magnitude should be defined');
+      near(r.mag, 0.98, 0.1);
+    });
+  });
+
+  describe('sweFixstar2', () => {
+    it('should match sweFixstar result', () => {
+      const r1 = sweFixstar(swed, 'Spica', J2000, SEFLG_MOSEPH);
+      const r2 = sweFixstar2(swed, 'Spica', J2000, SEFLG_MOSEPH);
+      near(r2.xx[0], r1.xx[0], 0.001);
+    });
+  });
+
+  describe('sweFixstar2Ut', () => {
+    it('should return valid position', () => {
+      const r = sweFixstar2Ut(swed, 'Spica', J2000, SEFLG_MOSEPH);
+      assert.ok(r.xx[0] > 0);
+    });
+  });
+
+  describe('sweFixstar2Mag', () => {
+    it('should return valid magnitude', () => {
+      const r = sweFixstar2Mag(swed, 'Spica');
+      assert.ok(r.mag !== undefined);
+    });
+  });
+});

package/tests/c-style/heliacal.test.ts

@@ -0,0 +1,34 @@
+import { describe, it, before, after } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { J2000, LONDON_ARR } from '../helpers';
+import { createDefaultSweData } from '../../src/types';
+import { sweSetTopo, sweClose } from '../../src/sweph';
+import { sweHeliacalUt, sweHeliacalPhenoUt, sweVisLimitMag } from '../../src/swehel';
+import { SEFLG_MOSEPH } from '../../src/constants';
+
+describe('Heliacal (C-style)', () => {
+  let swed: ReturnType<typeof createDefaultSweData>;
+
+  before(() => {
+    swed = createDefaultSweData();
+    sweSetTopo(swed, LONDON_ARR[0], LONDON_ARR[1], LONDON_ARR[2]);
+  });
+  after(() => { sweClose(swed); });
+
+  const datm = [1013.25, 10, 50, 0.25, 0, 0];
+  const dobs = [0, 0, 0, 0, 0, 0];
+
+  describe('sweHeliacalUt', () => {
+    it('Venus heliacal rising should return result', () => {
+      const r = sweHeliacalUt(swed, J2000, LONDON_ARR, datm, dobs, 'Venus', 1, SEFLG_MOSEPH);
+      assert.ok(typeof r.retval === 'number');
+    });
+  });
+
+  describe('sweVisLimitMag', () => {
+    it('should return a result for Venus', () => {
+      const r = sweVisLimitMag(swed, J2000, LONDON_ARR, datm, dobs, 'Venus', SEFLG_MOSEPH);
+      assert.ok(typeof r.retval === 'number');
+    });
+  });
+});

package/tests/c-style/houses.test.ts

@@ -0,0 +1,135 @@
+import { describe, it, before, after } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { near, J2000 } from '../helpers';
+import { createDefaultSweData } from '../../src/types';
+import { sweCalc, sweClose } from '../../src/sweph';
+import {
+  sweHouses, sweHousesEx, sweHousesEx2,
+  sweHousesArmc, sweHousesArmcEx2,
+  sweHousePos, sweHouseName,
+} from '../../src/swehouse';
+import { SE_SUN, SEFLG_MOSEPH, SEFLG_SPEED } from '../../src/constants';
+
+describe('Houses (C-style)', () => {
+  let swed: ReturnType<typeof createDefaultSweData>;
+
+  before(() => { swed = createDefaultSweData(); });
+  after(() => { sweClose(swed); });
+
+  describe('sweHouses (Placidus, London, J2000)', () => {
+    it('should produce valid AC and MC', () => {
+      const cusp = new Array(37).fill(0);
+      const ascmc = new Array(10).fill(0);
+      sweHouses(swed, J2000, 51.5074, -0.1278, 'P', cusp, ascmc);
+      near(ascmc[0], 24.03, 0.5);
+      near(ascmc[1], 279.50, 0.5);
+    });
+
+    it('cusp[1] should equal AC', () => {
+      const cusp = new Array(37).fill(0);
+      const ascmc = new Array(10).fill(0);
+      sweHouses(swed, J2000, 51.5074, -0.1278, 'P', cusp, ascmc);
+      near(cusp[1], ascmc[0], 0.001);
+    });
+  });
+
+  describe('sweHousesEx', () => {
+    it('should match sweHouses', () => {
+      const cusp1 = new Array(37).fill(0);
+      const ascmc1 = new Array(10).fill(0);
+      sweHouses(swed, J2000, 51.5074, -0.1278, 'P', cusp1, ascmc1);
+
+      const cusp2 = new Array(37).fill(0);
+      const ascmc2 = new Array(10).fill(0);
+      sweHousesEx(swed, J2000, SEFLG_MOSEPH, 51.5074, -0.1278, 'P', cusp2, ascmc2);
+      near(ascmc2[0], ascmc1[0], 0.001);
+    });
+  });
+
+  describe('sweHousesEx2', () => {
+    it('should match sweHouses', () => {
+      const cusp1 = new Array(37).fill(0);
+      const ascmc1 = new Array(10).fill(0);
+      sweHouses(swed, J2000, 51.5074, -0.1278, 'P', cusp1, ascmc1);
+
+      const cusp3 = new Array(37).fill(0);
+      const ascmc3 = new Array(10).fill(0);
+      sweHousesEx2(swed, J2000, SEFLG_MOSEPH, 51.5074, -0.1278, 'P', cusp3, ascmc3, null, null, null);
+      near(ascmc3[0], ascmc1[0], 0.001);
+    });
+  });
+
+  describe('sweHousesArmc', () => {
+    it('should produce AC close to sweHouses', () => {
+      const cusp = new Array(37).fill(0);
+      const ascmc = new Array(10).fill(0);
+      sweHouses(swed, J2000, 51.5074, -0.1278, 'P', cusp, ascmc);
+      const armc = ascmc[2];
+
+      const cuspA = new Array(37).fill(0);
+      const ascmcA = new Array(10).fill(0);
+      sweHousesArmc(armc, 51.5074, 23.44, 'P', cuspA, ascmcA);
+      near(ascmcA[0], ascmc[0], 0.5);
+    });
+  });
+
+  describe('sweHousesArmcEx2', () => {
+    it('should produce valid AC', () => {
+      const cusp = new Array(37).fill(0);
+      const ascmc = new Array(10).fill(0);
+      sweHouses(swed, J2000, 51.5074, -0.1278, 'P', cusp, ascmc);
+      const armc = ascmc[2];
+
+      const cuspB = new Array(37).fill(0);
+      const ascmcB = new Array(10).fill(0);
+      sweHousesArmcEx2(armc, 51.5074, 23.44, 'P', cuspB, ascmcB, null, null, null);
+      assert.ok(ascmcB[0] > 0);
+    });
+  });
+
+  describe('sweHousePos', () => {
+    it('Sun should be in house ~10 at J2000 London', () => {
+      const cusp = new Array(37).fill(0);
+      const ascmc = new Array(10).fill(0);
+      sweHouses(swed, J2000, 51.5074, -0.1278, 'P', cusp, ascmc);
+      const sun = sweCalc(swed, J2000, SE_SUN, SEFLG_MOSEPH | SEFLG_SPEED);
+      const hpos = sweHousePos(ascmc[2], 51.5074, 23.44, 'P', [sun.xx[0], sun.xx[1]], null);
+      assert.ok(hpos > 0 && hpos <= 12, `hpos=${hpos}`);
+      near(hpos, 10.05, 0.2);
+    });
+  });
+
+  describe('sweHouseName', () => {
+    it('should return Placidus for P', () => {
+      assert.strictEqual(sweHouseName('P'), 'Placidus');
+    });
+
+    it('should return Koch for K', () => {
+      assert.strictEqual(sweHouseName('K'), 'Koch');
+    });
+
+    it('should return equal for E', () => {
+      assert.ok(sweHouseName('E').toLowerCase().includes('equal'));
+    });
+
+    it('should return whole sign for W', () => {
+      assert.ok(sweHouseName('W').toLowerCase().includes('whole sign'));
+    });
+  });
+
+  describe('All house systems produce valid cusps', () => {
+    const systems = ['P', 'K', 'E', 'W', 'C', 'R', 'T', 'B', 'M', 'O'];
+
+    for (const sys of systems) {
+      it(`System ${sys} should produce 12 valid cusps`, () => {
+        const cusp = new Array(37).fill(0);
+        const ascmc = new Array(10).fill(0);
+        sweHouses(swed, J2000, 51.5074, -0.1278, sys, cusp, ascmc);
+        assert.ok(ascmc[0] > 0 && ascmc[0] < 360, `AC invalid for ${sys}`);
+        for (let i = 1; i <= 12; i++) {
+          assert.ok(cusp[i] >= 0 && cusp[i] < 360, `Cusp ${i} invalid for ${sys}`);
+        }
+      });
+    }
+  });
+});

package/tests/c-style/math-utils.test.ts

@@ -0,0 +1,160 @@
+import { describe, it } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { near } from '../helpers';
+import {
+  sweDegnorm, sweRadnorm, sweDegMidp, sweRadMidp,
+  sweCotrans, sweCotransSp, sweSplitDeg, sweD2l,
+  sweCsnorm, sweDifcsn, sweDifcs2n, sweDifdegn, sweDifrad2n,
+  sweCsroundsec,
+  sweCs2timestr, sweCs2lonlatstr, sweCs2degstr,
+  swiCutstr, swiRightTrim, swiStrcpy, swiOpenTrace,
+} from '../../src/swephlib';
+import { sweDifdeg2n } from '../../src/sweph';
+import { SE_SPLIT_DEG_ZODIACAL, SE_SPLIT_DEG_ROUND_SEC } from '../../src/constants';
+
+describe('Math Utilities (C-style)', () => {
+  describe('sweDegnorm', () => {
+    it('370 -> 10', () => { near(sweDegnorm(370), 10, 0.001); });
+    it('-10 -> 350', () => { near(sweDegnorm(-10), 350, 0.001); });
+    it('0 -> 0', () => { near(sweDegnorm(0), 0, 0.001); });
+    it('360 -> 0', () => { near(sweDegnorm(360), 0, 0.001); });
+  });
+
+  describe('sweRadnorm', () => {
+    it('7 -> 7-2pi', () => {
+      near(sweRadnorm(7), 7 - 2 * Math.PI, 0.001);
+    });
+  });
+
+  describe('sweDegMidp', () => {
+    it('midpoint of 10,350 -> 0', () => {
+      near(sweDegMidp(10, 350), 0, 0.001);
+    });
+
+    it('midpoint of 90,270 -> 0 or 180', () => {
+      const m = sweDegMidp(90, 270);
+      assert.ok(Math.abs(m) < 0.001 || Math.abs(m - 180) < 0.001,
+        `midpoint=${m}`);
+    });
+  });
+
+  describe('sweRadMidp', () => {
+    it('should return positive value', () => {
+      assert.ok(sweRadMidp(0.1, 6.1) >= 0);
+    });
+  });
+
+  describe('sweCotrans', () => {
+    it('should transform ecliptic to equatorial', () => {
+      const xpo = [280.0, -0.5, 1.0];
+      const xpn = [0, 0, 0];
+      sweCotrans(xpo, xpn, 23.44);
+      assert.ok(xpn[0] !== 0 || xpn[1] !== 0);
+    });
+  });
+
+  describe('sweCotransSp', () => {
+    it('should transform with speed', () => {
+      const xpo = [280.0, -0.5, 1.0, 1.0, 0.1, 0];
+      const xpn = [0, 0, 0, 0, 0, 0];
+      sweCotransSp(xpo, xpn, 23.44);
+      assert.ok(xpn[0] !== 0);
+    });
+  });
+
+  describe('sweDifdeg2n', () => {
+    it('10,350 -> 20', () => { near(sweDifdeg2n(10, 350), 20, 0.001); });
+    it('350,10 -> -20', () => { near(sweDifdeg2n(350, 10), -20, 0.001); });
+  });
+
+  describe('sweDifdegn', () => {
+    it('10,350 -> 20', () => { near(sweDifdegn(10, 350), 20, 0.001); });
+  });
+
+  describe('sweDifrad2n', () => {
+    it('pi,0 -> -pi', () => { near(sweDifrad2n(Math.PI, 0), -Math.PI, 0.001); });
+  });
+
+  describe('sweD2l', () => {
+    it('2.5 -> 3', () => { assert.strictEqual(sweD2l(2.5), 3); });
+    it('-2.5 -> -3', () => { assert.strictEqual(sweD2l(-2.5), -3); });
+    it('2.4 -> 2', () => { assert.strictEqual(sweD2l(2.4), 2); });
+  });
+
+  describe('sweSplitDeg', () => {
+    it('should split 123.456', () => {
+      const sp = sweSplitDeg(123.456, SE_SPLIT_DEG_ZODIACAL | SE_SPLIT_DEG_ROUND_SEC);
+      assert.ok(sp.deg >= 0 && sp.deg < 30);
+      assert.ok(sp.min >= 0 && sp.min < 60);
+      assert.ok(sp.sec >= 0 && sp.sec < 60);
+    });
+  });
+
+  describe('sweCsnorm', () => {
+    it('should normalize centiseconds', () => {
+      assert.strictEqual(sweCsnorm(360 * 360000 + 100), 100);
+    });
+  });
+
+  describe('sweDifcsn / sweDifcs2n / sweCsroundsec', () => {
+    it('should return numbers', () => {
+      assert.strictEqual(typeof sweDifcsn(100, 200), 'number');
+      assert.strictEqual(typeof sweDifcs2n(100, 200), 'number');
+      assert.strictEqual(typeof sweCsroundsec(12345), 'number');
+    });
+  });
+
+  describe('Formatting', () => {
+    it('sweCs2timestr noon', () => {
+      const ts = sweCs2timestr(12 * 3600 * 100, ':', false);
+      assert.ok(ts.includes('12'), ts);
+    });
+
+    it('sweCs2lonlatstr 90 deg', () => {
+      const s = sweCs2lonlatstr(90 * 3600 * 100, 'E', 'W');
+      assert.ok(s.includes('90'), s);
+    });
+
+    it('sweCs2degstr 15 deg', () => {
+      const s = sweCs2degstr(15 * 3600 * 100);
+      assert.ok(s.includes('15'), s);
+    });
+  });
+
+  describe('String utilities', () => {
+    it('swiCutstr basic split', () => {
+      const r = swiCutstr('hello,world,foo', ',');
+      assert.strictEqual(r.length, 3);
+      assert.strictEqual(r[0], 'hello');
+      assert.strictEqual(r[2], 'foo');
+    });
+
+    it('swiCutstr collapses separators', () => {
+      const r = swiCutstr('a,,b,,c', ',');
+      assert.strictEqual(r.length, 3);
+      assert.strictEqual(r[1], 'b');
+    });
+
+    it('swiCutstr nmax', () => {
+      const r = swiCutstr('a,b,c,d,e', ',', 3);
+      assert.strictEqual(r.length, 3);
+      assert.strictEqual(r[2], 'c,d,e');
+    });
+
+    it('swiRightTrim trims spaces', () => {
+      assert.strictEqual(swiRightTrim('hello   '), 'hello');
+    });
+
+    it('swiRightTrim trims tabs', () => {
+      assert.strictEqual(swiRightTrim('hello\t \n'), 'hello');
+    });
+
+    it('swiStrcpy identity', () => {
+      assert.strictEqual(swiStrcpy('test'), 'test');
+    });
+
+    it('swiOpenTrace should not throw', () => {
+      swiOpenTrace();
+    });
+  });
+});