diff --git a/src/firefly/js/astro/conv/__test__/CoordConv-test.js b/src/firefly/js/astro/conv/__test__/CoordConv-test.js
new file mode 100644
index 0000000000..7d5cf74fb8
--- /dev/null
+++ b/src/firefly/js/astro/conv/__test__/CoordConv-test.js
@@ -0,0 +1,790 @@
+/*eslint-env node, mocha */
+import {expect,assert} from 'chai';
+import {doConv, doConvPM} from '../CoordConv.js';
+const  EQUATORIAL_J = 0;
+const EQUATORIAL_B = 1;
+const  GALACTIC = 2;
+const  ECLIPTIC_B = 3;
+const SUPERGALACTIC = 4;
+const ECLIPTIC_J = 13;
+const EQINOX2000=2000.0;
+const EQINOX1950=1950.0;
+const precision=10;
+describe('A test suite for CoordConv.js', function () {
+
+
+    it('should be equal when convert from inCoord = EQUATORIAL_J, to outCoord = coordianteSys where inEquirox=outEquinox=2000', function () {
+         const coordianteSys = [
+             //EQUATORIAL_J,
+             EQUATORIAL_B,
+             GALACTIC,
+             ECLIPTIC_B,
+             SUPERGALACTIC
+         ];
+         const expectedLons = [
+             124.53450295504638,
+             254.14759117810968,
+             140.5026330845168,
+             167.8940515712723
+         ];
+         const expectedLats =[
+              -35.95580982205028,
+              -0.0946854772394013,
+              -53.509857120978175,
+              -62.562888161876515
+         ];
+         const  inLon =  124.534666;
+         const inLat =  -35.955853;
+         var lons = [];
+         var lats = [];
+         var ret;
+         const tobs=0.0;
+         const inCoord = EQUATORIAL_J;
+         for (let i = 0; i < coordianteSys.length; i++){
+            ret  =   doConv(inCoord, EQINOX2000,
+                 inLon, inLat,
+                 coordianteSys[i], EQINOX2000, tobs);
+             lons[i]=ret.lon;
+             lats[i]=ret.lat;
+         }
+        for (let i=0; i<lons.length; i++){
+            expect(lons[i].toFixed( precision), `${i} th lon  not equal` ).to.equal(expectedLons[i].toFixed( precision));
+            expect(lats[i].toFixed( precision), `${i} th lat not equal`).to.equal(expectedLats[i].toFixed( precision));
+        }
+
+     });
+
+
+    it('should be equal when convert from inCoord = EQUATORIAL_B, to outCoord = coordianteSys where inEquirox=outEquinox=2000', function () {
+        const coordianteSys = [
+            EQUATORIAL_J,
+            //EQUATORIAL_B,
+            GALACTIC,
+            ECLIPTIC_B,
+            SUPERGALACTIC
+        ];
+        const expectedLons = [124.53482902154403,  254.14770106291908, 140.5028659746326, 167.89392878562498];
+        const expectedLats =[-35.95589617435087,   -0.0946006066378949, -53.50984702816197, -62.56276136778953];
+        const  inLon =  124.534666;
+        const inLat =  -35.955853;
+        // LonLat[] lonLat= new LonLat[coordianteSys.length];
+        var lons = [];
+        var lats = [];
+        var ret;
+        const tobs=0.0;
+        const inCoord = EQUATORIAL_B;
+        for (let i = 0; i < coordianteSys.length; i++){
+            ret  =   doConv(inCoord, EQINOX2000,
+                inLon, inLat,
+                coordianteSys[i], EQINOX2000, tobs);
+            lons[i]=ret.lon;
+            lats[i]=ret.lat;
+        }
+
+        for (let i=0; i<lons.length; i++){
+            expect(lons[i].toFixed(precision), `${i} th lon  not equal` ).to.equal(expectedLons[i].toFixed(precision));
+            expect(lats[i].toFixed(precision), `${i} th lat not equal`).to.equal(expectedLats[i].toFixed(precision));
+        }
+
+    });
+
+
+
+    it('should be equal when convert from inCoord = GALACTIC, to outCoord = coordianteSys where inEquirox=outEquinox=2000', function () {
+        const coordianteSys = [
+            EQUATORIAL_J,
+            EQUATORIAL_B,
+            //GALACTIC,
+            ECLIPTIC_B,
+            SUPERGALACTIC
+        ];
+        const expectedLons = [
+             14.314192367676567,
+             14.313891114646578,
+             23.862153926328073,
+             322.6015293667469
+        ];
+        const expectedLats =[
+            26.897737748051213,
+            26.897721362584967,
+            19.108830668361076,
+            6.55143894512179
+        ];
+        const  inLon =  124.534666;
+        const inLat =  -35.955853;
+        // LonLat[] lonLat= new LonLat[coordianteSys.length];
+        var lons = [];
+        var lats = [];
+        var ret;
+        const tobs=0.0;
+        const inCoord = GALACTIC;
+        for (let i = 0; i < coordianteSys.length; i++){
+            ret  =   doConv(inCoord, EQINOX2000,
+                inLon, inLat,
+                coordianteSys[i], EQINOX2000, tobs);
+            lons[i]=ret.lon;
+            lats[i]=ret.lat;
+        }
+
+        for (let i=0; i<lons.length; i++){
+            expect(lons[i].toFixed(precision), `${i} th lon  not equal` ).to.equal(expectedLons[i].toFixed(precision));
+            expect(lats[i].toFixed(precision), `${i} th lat not equal`).to.equal(expectedLats[i].toFixed(precision));
+        }
+
+    });
+
+
+
+    it('should be equal when convert from inCoord = ECLIPTIC_B, to outCoord = coordianteSys where inEquirox=outEquinox=2000', function () {
+        const coordianteSys = [
+            EQUATORIAL_J,
+            EQUATORIAL_B,
+            GALACTIC,
+            //ECLIPTIC_B,
+            SUPERGALACTIC
+        ];
+        const expectedLons = [
+             118.49488604196446,
+             118.49466903172939,
+             234.2557377542504,
+             119.11472767964223
+        ];
+        const expectedLats =[
+            -15.870385824487494,
+            -15.87036211628557,
+            6.086441566001859,
+            -75.81735095264665
+        ];
+        const  inLon =  124.534666;
+        const inLat =  -35.955853;
+        // LonLat[] lonLat= new LonLat[coordianteSys.length];
+        var lons = [];
+        var lats = [];
+        var ret;
+        const tobs=0.0;
+        const inCoord = ECLIPTIC_B;
+        for (let i = 0; i < coordianteSys.length; i++){
+            ret  =   doConv(inCoord, EQINOX2000,
+                inLon, inLat,
+                coordianteSys[i], EQINOX2000, tobs);
+            lons[i]=ret.lon;
+            lats[i]=ret.lat;
+        }
+
+        for (let i=0; i<lons.length; i++){
+            expect(lons[i].toFixed(precision), `${i} th lon  not equal` ).to.equal(expectedLons[i].toFixed(precision));
+            expect(lats[i].toFixed(precision), `${i} th lat not equal`).to.equal(expectedLats[i].toFixed(precision));
+        }
+
+   });
+
+    it('should convert from inCoord = SUPERGALACTIC, to outCoord = coordianteSys where inEquirox=outEquinox=2000', function () {
+        // Test implementation goes here
+        const coordianteSys = [
+            EQUATORIAL_J,
+            EQUATORIAL_B,
+            GALACTIC,
+            ECLIPTIC_B,
+            //SUPERGALACTIC
+        ];
+        const expectedLons = [
+            160.05774114616887,
+            160.05747714105252,
+            262.30305234915625,
+            167.87051071206182
+        ];
+        const expectedLats =[
+            -15.578527433407034,
+            -15.578455616476347,
+            36.73676677794771,
+            -22.153262855160243
+        ];
+        const  inLon =  124.534666;
+        const inLat =  -35.955853;
+        // LonLat[] lonLat= new LonLat[coordianteSys.length];
+        var lons = [];
+        var lats = [];
+        var ret;
+        const tobs=0.0;
+        const inCoord = SUPERGALACTIC;
+        for (let i = 0; i < coordianteSys.length; i++){
+            ret  =   doConv(inCoord, EQINOX2000,
+                inLon, inLat,
+                coordianteSys[i], EQINOX2000, tobs);
+            lons[i]=ret.lon;
+            lats[i]=ret.lat;
+        }
+
+        for (let i=0; i<lons.length; i++){
+            expect(lons[i].toFixed(precision), `${i} th lon  not equal` ).to.equal(expectedLons[i].toFixed(precision));
+            expect(lats[i].toFixed(precision), `${i} th lat not equal`).to.equal(expectedLats[i].toFixed(precision));
+        }
+
+    });
+
+
+    it('should be equal when convert from inCoord = ECLIPTIC_B, to outCoord =ECLIPTIC_J where inEquirox=outEquinox=1950', function () {
+        const expectedLon = 124.5347532192079;
+        const expectedLat =-35.95583152511536;
+        const  inLon =  124.534666;
+        const inLat =  -35.955853;
+
+        const tobs=0.0;
+        const inCoord = ECLIPTIC_B;
+        const outCoord = ECLIPTIC_J;
+
+
+        var ret  = doConv(inCoord, EQINOX1950,inLon, inLat,outCoord, EQINOX1950, tobs);
+
+        var lon =ret.lon;
+        var lat=ret.lat;
+
+
+        expect(lon.toFixed(7), 'lon  not equal').to.equal(expectedLon.toFixed(7));
+        expect(lat.toFixed(7), 'lat not equal' ).to.equal(expectedLat.toFixed(7));
+
+    });
+
+
+    it('should be equal when convert from inCoord = ECLIPTIC_J, to outCoord =ECLIPTIC_B where inEquirox=outEquinox=1950', function () {
+        const expectedLon = 124.53457878080559;
+        const expectedLat =-35.9558744748764;
+        const  inLon =  124.534666;
+        const inLat =  -35.955853;
+
+        const tobs=0.0;
+        const inCoord = ECLIPTIC_J;
+        const outCoord = ECLIPTIC_B;
+
+
+        var ret  = doConv(inCoord, EQINOX1950, inLon, inLat,outCoord, EQINOX1950, tobs);
+
+        var lon =ret.lon;
+        var lat=ret.lat;
+
+
+        expect(lon.toFixed(precision), 'lon  not equal').to.equal(expectedLon.toFixed(precision));
+        expect(lat.toFixed(precision), 'lat not equal' ).to.equal(expectedLat.toFixed(precision));
+
+    });
+
+
+
+    it('should be equal when convert from inCoord = EQUATORIAL_B,inEquirox=20000 , to outCoord array where outEquinox=1950', function () {
+        const coordianteSys = [
+            EQUATORIAL_J,
+            // EQUATORIAL_B,
+            GALACTIC,
+            ECLIPTIC_B,
+            SUPERGALACTIC,
+            ECLIPTIC_B,
+            ECLIPTIC_J
+        ];
+        const expectedLons = [
+             189.36453921014683,
+             289.97256953016654,
+             183.72633259856838,
+             103.6528039980443,
+             183.72633259856838,
+             183.72661635258902
+        ];
+        const expectedLats =[
+            12.06512707543329,
+            74.58398219233717,
+            14.777604604170802,
+            -0.8857277432637922,
+            14.777604604170802,
+            14.777729481820373
+        ];
+
+        const inLon =   188.733333;//124.534666;
+        const inLat =   12.34;//-35.955853;
+
+        var lons = [];
+        var lats = [];
+        var ret;
+        const tobs=1983.5;
+        const inCoord = EQUATORIAL_B;
+        for (let i = 0; i < coordianteSys.length; i++){
+            ret  =   doConv(inCoord, EQINOX1950,
+                inLon, inLat,
+                coordianteSys[i], EQINOX2000, tobs);
+            lons[i]=ret.lon;
+            lats[i]=ret.lat;
+        }
+
+        for (let i=0; i<lons.length; i++){
+            expect(lons[i].toFixed(precision), `${i} th lon  not equal` ).to.equal(expectedLons[i].toFixed(precision));
+            expect(lats[i].toFixed(precision), `${i} th lat not equal`).to.equal(expectedLats[i].toFixed(precision));
+        }
+
+
+    });
+
+    it('should be equal when handle the Proper Motion conversion from Equatorial B1950 to J2000', function () {
+
+        const expected={
+            ra:189.37874706190132,
+            dec: 12.065158672309735,
+            raPM: 1.0012468839571316,
+            decPM:0.005252980797938754
+        };
+        const in_lon = 188.733333;
+        const  in_lat = 12.34;
+        const  in_pmlon = 1.0;
+        const  in_pmlat = 0.0;
+
+
+        var fromB1950ToJ2000=true;
+        var result = doConvPM( fromB1950ToJ2000 ,in_lon,  in_lat,in_pmlon, in_pmlat) ;
+
+
+        Object.keys(result).forEach(function(key) {
+            expect(result[key].toFixed(precision), 'lon  not equal').to.equal(expected[key].toFixed(precision) );
+        });
+
+
+    });
+
+
+    it('should be equal when handle the Proper Motion conversion from Equatorial J2000 to B1950', function () {
+
+        const expected={
+            ra:188.08745733910888,
+            dec:  12.615389043008733,
+            raPM: 0.998835388671965,
+            decPM:-0.0052536804247012465
+        };
+
+        const in_lon = 188.733333;
+        const  in_lat = 12.34;
+        const  in_pmlon = 1.0;
+        const  in_pmlat = 0.0;
+
+
+        var fromB1950ToJ2000=false;
+        var result =doConvPM( fromB1950ToJ2000 ,in_lon,  in_lat,in_pmlon, in_pmlat) ;
+
+
+
+        Object.keys(result).forEach(function(key) {
+            expect(result[key].toFixed(precision), 'lon  not equal').to.equal(expected[key].toFixed(precision) );
+        });
+
+
+    });
+
+
+
+    it('should be equal when convert from inCoord = EQUATORIAL_J,inEquirox=20000 , to outCoord=EQUATORIAL_B outEquinox=1950 lat=-90,',  function () {
+
+        const expectedLons = [
+            179.69493905911276,
+            179.6949390591126,
+            179.69493905911244,
+            179.69493905911233,
+            179.69493905911222,
+            179.69493905911213,
+            179.69493905911207,
+            179.69493905911202,
+            179.69493905911202,
+            179.69493905911204,
+             179.6949390591121,
+             179.6949390591122,
+             179.6949390591123,
+             179.69493905911244,
+             179.69493905911258,
+             179.69493905911273,
+             179.6949390591129,
+             179.69493905911304,
+             179.69493905911318,
+             179.69493905911327,
+             179.69493905911335,
+             179.6949390591134,
+             179.69493905911347,
+             179.69493905911347,
+             179.69493905911344,
+             179.69493905911338,
+             179.6949390591133,
+             179.69493905911318,
+             179.69493905911304,
+             179.6949390591129,
+             179.69493905911276
+        ];
+        const expectedLats =[
+            -89.72157064600971
+            -89.72157064600971
+            -89.72157064600971
+            -89.72157064600971
+            -89.72157064600971
+            -89.72157064600971
+            -89.72157064600971
+            -89.72157064600971
+            -89.72157064600971
+            -89.72157064600968
+             -89.7215706460096,
+             -89.7215706460096,
+             -89.7215706460096,
+             -89.7215706460096,
+             -89.7215706460096,
+             -89.7215706460096,
+             -89.7215706460096,
+             -89.7215706460096,
+             -89.7215706460096,
+             -89.7215706460096,
+             -89.7215706460096,
+             -89.7215706460096,
+             -89.7215706460097,
+             -89.7215706460097,
+             -89.7215706460097,
+             -89.7215706460097,
+             -89.7215706460097,
+             -89.7215706460097,
+             -89.7215706460097,
+             -89.7215706460097,
+             -89.72157064600971
+        ];
+
+        const deltaLon=12.0;
+
+        var lons =[];
+
+
+        for (let i=0; i<31; i++){
+            lons[i] = deltaLon*i;
+        }
+
+        const inLat =  -90;//-35.955853;
+
+        var lons = [];
+        var lats = [];
+        var ret;
+        const tobs=1983.5;
+        const inCoord = EQUATORIAL_J;
+        const outCoord = EQUATORIAL_B;
+        for (let i = 0; i < lons.length; i++){
+            ret  =   doConv(inCoord, EQINOX2000,
+                lons[i], inLat,
+                outCoord, EQINOX1950, tobs);
+            lons[i]=ret.lon;
+            lats[i]=ret.lat;
+        }
+
+        for (let i=0; i<lons.length; i++){
+            expect(lons[i].toFixed(precision), `${i} th lon  not equal` ).to.equal(expectedLons[i].toFixed(precision));
+            expect(lats[i].toFixed(precision), `${i} th lat not equal`).to.equal(expectedLats[i].toFixed(precision));
+        }
+
+
+    });
+
+    it('should be equal when convert from inCoord = EQUATORIAL_J,inEquirox=20000 , to outCoord=EQUATORIAL_B outEquinox=1950 lat=0.0',  function () {
+
+        const expectedLons = [
+            359.3592849828098,
+            11.359438904263449,
+            23.359566843235793,
+            35.359650057376456,
+            47.359677830602095,
+            59.35964940454754,
+            71.35956484441512,
+            83.35944478971054,
+            95.35931135011296,
+            107.35918709318142,
+             119.35908986175045,
+             131.3590421568453,
+             143.35904600332142,
+             155.3591007329216,
+             167.3591963210104,
+             179.35931461851578,
+             191.35943370129027,
+             203.35953056942128,
+             215.35958518331051,
+             227.35958610780577,
+             239.35953390722406,
+             251.35942969109652,
+             263.35929009885723,
+             275.359141930767,
+             287.3590120840817,
+             299.35892108133567,
+             311.3588895795302,
+             323.3589192601622,
+             335.359005963513,
+             347.3591355634421,
+             359.3592849828098
+        ];
+        const expectedLats =[
+           -0.2783452467691817,
+           -0.27258880994923246,
+           -0.2549168566135561,
+           -0.22610388924970531,
+           -0.18741017409840746,
+           -0.140524933281613,
+           -0.0874966364959342,
+           -0.030644779011098463,
+           0.027545426167679507,
+           0.084531511433299,
+            0.13782588020254463,
+            0.18509716721558142,
+            0.2242802023550557,
+            0.25366068042758827,
+            0.2719535488741306,
+            0.27836006972495225,
+            0.2726021733065438,
+            0.2549288290606657,
+            0.22611358589813,
+            0.18741641466087752,
+            0.14052771512116813,
+            0.08749733253305987,
+            0.030643405348049723,
+            -0.027548326428057907,
+            -0.08453481107285257,
+            -0.13782788666203,
+            -0.1850936532441476,
+            -0.22427098142081875,
+            -0.25364740528097,
+            -0.27193864159257625,
+            -0.2783452467691817
+        ];
+
+        const deltaLon=12.0;
+
+        var lons =[];
+
+
+        for (let i=0; i<31; i++){
+            lons[i] = deltaLon*i;
+        }
+
+        const inLat = 0.0;
+
+        var lons = [];
+        var lats = [];
+        var ret;
+        const tobs=1983.5;
+        const inCoord = EQUATORIAL_J;
+        const outCoord = EQUATORIAL_B;
+        for (let i = 0; i < lons.length; i++){
+            ret  =   doConv(inCoord, EQINOX2000,
+                lons[i], inLat,
+                outCoord, EQINOX1950, tobs);
+            lons[i]=ret.lon;
+            lats[i]=ret.lat;
+        }
+
+        for (let i=0; i<lons.length; i++){
+            expect(lons[i].toFixed(precision), `${i} th lon  not equal` ).to.equal(expectedLons[i].toFixed(precision));
+            expect(lats[i].toFixed(precision), `${i} th lat not equal`).to.equal(expectedLats[i].toFixed(precision));
+        }
+
+
+    });
+
+
+    it('should be equal when convert from inCoord = EQUATORIAL_J,inEquirox=20000 , to outCoord=ECLIPTIC_B outEquinox=1950 lat=-90.0',  function () {
+
+        const expectedLons = [
+            359.68340855555186,
+            359.68340855555203,
+            359.68340855555215,
+            359.6834085555523,
+            359.6834085555524,
+            359.6834085555525,
+            359.68340855555255,
+            359.6834085555526,
+            359.6834085555526,
+            359.68340855555255,
+             359.6834085555525,
+             359.6834085555524,
+             359.6834085555523,
+             359.68340855555215,
+             359.68340855555203,
+             359.68340855555186,
+             359.68340855555175,
+             359.6834085555516,
+             359.68340855555147,
+             359.68340855555135,
+             359.68340855555124,
+             359.6834085555512,
+             359.6834085555511,
+             359.6834085555511,
+             359.6834085555512,
+             359.68340855555124,
+             359.68340855555135,
+             359.6834085555514,
+             359.6834085555516,
+             359.6834085555517,
+             359.68340855555186
+        ];
+        const expectedLats =[
+           89.72175645220416,
+           89.72175645220416,
+           89.72175645220416,
+           89.72175645220416,
+           89.72175645220416,
+           89.72175645220416,
+           89.72175645220416,
+           89.72175645220416,
+           89.72175645220416,
+           89.72175645220416,
+            89.72175645220416,
+            89.72175645220416,
+            89.72175645220416,
+            89.72175645220416,
+            89.72175645220416,
+            89.72175645220416,
+            89.72175645220416,
+            89.72175645220416,
+            89.72175645220416,
+            89.72175645220416,
+            89.72175645220416,
+            89.72175645220416,
+            89.72175645220416,
+            89.72175645220416,
+            89.72175645220416,
+            89.72175645220416,
+            89.72175645220416,
+            89.72175645220416,
+            89.72175645220416,
+            89.72175645220416,
+            89.72175645220416
+        ];
+
+        const deltaLon=12.0;
+
+        var lons =[];
+
+
+        for (let i=0; i<31; i++){
+            lons[i] = deltaLon*i;
+        }
+
+        const inLat =90.0;
+
+        var lons = [];
+        var lats = [];
+        var ret;
+        const tobs=1983.5;
+        const inCoord = EQUATORIAL_J;
+        const outCoord = EQUATORIAL_B;
+        for (let i = 0; i < lons.length; i++){
+            ret  =   doConv(inCoord, EQINOX2000,
+                lons[i], inLat,
+                outCoord, EQINOX1950, tobs);
+            lons[i]=ret.lon;
+            lats[i]=ret.lat;
+        }
+
+        for (let i=0; i<lons.length; i++){
+            expect(lons[i].toFixed(precision), `${i} th lon  not equal` ).to.equal(expectedLons[i].toFixed(precision));
+            expect(lats[i].toFixed(precision), `${i} th lat not equal`).to.equal(expectedLats[i].toFixed(precision));
+        }
+
+
+    });
+
+
+    it('should be equal when convert from inCoord = EQUATORIAL_J,inEquirox=20000 , to outCoord=EQUATORIAL_B outEquinox=1950 lat=90.0',  function () {
+
+        const expectedLons = [
+           69.3002173418388,
+           69.3002173418388,
+           69.3002173418388,
+           69.3002173418388,
+           69.3002173418388,
+           69.3002173418388,
+           69.3002173418388,
+           69.3002173418388,
+           69.3002173418388,
+           69.3002173418387,
+           269.3002173418387,
+           269.3002173418387,
+           269.3002173418387,
+           269.3002173418387,
+           269.3002173418387,
+           269.3002173418387,
+           269.3002173418387,
+           269.3002173418387,
+           269.3002173418387,
+           269.3002173418387,
+           269.3002173418387,
+           269.3002173418387,
+           269.3002173418388,
+           269.3002173418388,
+           269.3002173418388,
+           269.3002173418388,
+           269.3002173418388,
+           269.3002173418388,
+           269.3002173418388,
+           269.3002173418388,
+           269.3002173418388
+        ];
+        const expectedLats =[
+           -66.55413363542428,
+           -66.55413363542428,
+           -66.55413363542428,
+           -66.55413363542428,
+           -66.55413363542428,
+           -66.55413363542428,
+           -66.55413363542428,
+           -66.55413363542428,
+           -66.55413363542428,
+           -66.55413363542428,
+            -66.55413363542428,
+            -66.55413363542428,
+            -66.55413363542428,
+            -66.55413363542428,
+            -66.55413363542428,
+            -66.55413363542428,
+            -66.55413363542428,
+            -66.55413363542428,
+            -66.55413363542428,
+            -66.55413363542428,
+            -66.55413363542428,
+            -66.55413363542428,
+            -66.55413363542428,
+            -66.55413363542428,
+            -66.55413363542428,
+            -66.55413363542428,
+            -66.55413363542428,
+            -66.55413363542428,
+            -66.55413363542428,
+            -66.55413363542428,
+            -66.55413363542428
+        ];
+
+        const deltaLon=12.0;
+
+        var lons =[];
+
+
+        for (let i=0; i<31; i++){
+            lons[i] = deltaLon*i;
+        }
+
+        const inLat =90.0;
+
+        var lons = [];
+        var lats = [];
+        var ret;
+        const tobs=1983.5;
+        const inCoord = EQUATORIAL_J;
+        const outCoord =  ECLIPTIC_B;
+        for (let i = 0; i < lons.length; i++){
+            ret  =   doConv(inCoord, EQINOX2000,
+                lons[i], inLat,
+                outCoord, EQINOX1950, tobs);
+            lons[i]=ret.lon;
+            lats[i]=ret.lat;
+        }
+
+        for (let i=0; i<lons.length; i++){
+            expect(lons[i].toFixed(precision), `${i} th lon  not equal` ).to.equal(expectedLons[i].toFixed(precision));
+            expect(lats[i].toFixed(precision), `${i} th lat not equal`).to.equal(expectedLats[i].toFixed(precision));
+        }
+
+
+    });
+
+
+});
\ No newline at end of file
diff --git a/src/firefly/js/tables/__test__/TablesCntlr-test.js b/src/firefly/js/tables/__test__/TablesCntlr-test.js
index 5b5e9471d4..be5bf78b41 100644
--- a/src/firefly/js/tables/__test__/TablesCntlr-test.js
+++ b/src/firefly/js/tables/__test__/TablesCntlr-test.js
@@ -3,14 +3,14 @@
 import {expect} from 'chai';
 import {assert} from 'chai';
 
-import { makeTblRequest} from '../TableUtil.js';
+//mport { makeTblRequest} from '../TableUtil.js';
 
 describe('A test suite for tables/TablesCntlr.js', function () {
     var request;
 
     /* run once before testing */
     before(() => {
-            request = makeTblRequest('IpacTableFromSource');
+           // request = makeTblRequest('IpacTableFromSource');
         }
     );
     /* run once testing is done */
diff --git a/src/firefly/js/visualize/projection/Projection.js b/src/firefly/js/visualize/projection/Projection.js
index 9e14d1a1f5..6798ab6d6c 100644
--- a/src/firefly/js/visualize/projection/Projection.js
+++ b/src/firefly/js/visualize/projection/Projection.js
@@ -121,13 +121,10 @@ const projTypes= {
 	}
 };
 
-const getProjTypeInfo= (header) => projTypes[get(header,'maptype', UNRECOGNIZED)];
-
-
-const translateProjectionName= (header) => getProjTypeInfo(header).name;
-const isImplemented= (header) => getProjTypeInfo(header).implemented;
-const isWrappingProjection= (header) => getProjTypeInfo(header).wrapping;
 
+const translateProjectionName= (maptype) => get(projTypes, [maptype,'name'],'UNRECOGNIZED');
+const isImplemented= (header) => get(header, ['maptype.implemented'],false);
+const isWrappingProjection= (header) => get(header, ['maptype.wrapping'],false);
 
 
 
@@ -156,7 +153,11 @@ function getWorldCoordsInternal(x, y, header, coordSys)  {
  * @return ImagePt with X,Y in 'Skyview Screen' coordinates
  */
 function getImageCoordsInternal(ra, dec, header) {
+	//console.log('in Project.js');
+	//console.log(header);
+	//console.log(header.maptype);
 	if (!projTypes[header.maptype]) return null;
+	//console.log(projTypes[header.maptype]);
 	const image_pt = projTypes[header.maptype].revProject( ra, dec, header);
 	return image_pt;
 }
diff --git a/src/firefly/js/visualize/projection/__test__/ProjectTest.js b/src/firefly/js/visualize/projection/__test__/ProjectTest.js
deleted file mode 100644
index 096242f804..0000000000
--- a/src/firefly/js/visualize/projection/__test__/ProjectTest.js
+++ /dev/null
@@ -1,24 +0,0 @@
-
-import {describe, expect, it, assert} from 'chai';
-import {Projection, makeProjection} from '../Projection.js';
-
-import {Projection} from '../Projection.js';
-
-describe('A test suite for projection.js', function () {
-    /* run once before testing */
-    var jsonObj;
-    before(() => {
-       //jsonObj = loadJsonObj();
-
-        }
-    );
- //TODO add test below
-    it('should have a header and a coordinate parameters', function() {
-        // Test implementation goes here
-        var gwtProject = 'load gwt project here';
-
-        var jsProject = makeProjection(jsonObj);
-        assert.equal(jsProject, gwtProject);
-    });
-
-});
\ No newline at end of file
diff --git a/src/firefly/js/visualize/projection/__test__/Projection-test.js b/src/firefly/js/visualize/projection/__test__/Projection-test.js
new file mode 100644
index 0000000000..718ad521c8
--- /dev/null
+++ b/src/firefly/js/visualize/projection/__test__/Projection-test.js
@@ -0,0 +1,124 @@
+/*eslint-env node, mocha */
+import {expect,assert} from 'chai';
+import {Projection, makeProjection} from '../Projection.js';
+import CoordinateSys from '../../CoordSys.js';
+
+/**
+ * LZ finalized on 8/30/16
+ * The javascript unit test uses the same data in the java unit test tree.
+ *
+ */
+var fs = require('fs');
+
+const JAVA_TEST_DATA_PATH='firefly_test_data/edu/caltech/ipac/visualize/plot/projection/';
+
+const precision=10;
+
+var projectionJson={};
+
+
+const projTypes = {
+    GNOMONIC   : 1001,
+    ORTHOGRAPHIC : 1002,
+    NCP          : 1003,
+    AITOFF       : 1004,
+    CAR          : 1005,
+    LINEAR       : 1006,
+    PLATE        : 1007,
+    ARC          : 1008,
+    SFL          : 1009,
+    CEA          : 1010,
+    UNSPECIFIED  : 1998,
+    UNRECOGNIZED : 1999
+};
+
+function getJsonFiles(dir){
+    var fileList = [];
+
+    var files = fs.readdirSync(dir);
+    for(var i in files){
+        if (!files.hasOwnProperty(i)) continue;
+        var name = dir+'/'+files[i];
+        if (!fs.statSync(name).isDirectory() && name.endsWith('json') ){
+            fileList.push(name);
+        }
+    }
+    return fileList;
+}
+
+describe('A test suite for projection.js', function () {
+
+
+
+    describe('This is to test all json files stored in the testing directory', function () {
+
+
+        var path = require('path');
+        //__filename returns absolute path to file where it is placed
+        var scriptDirString = path.dirname(fs.realpathSync(__filename));
+
+       //the abosolute root path to js/ not include js
+       // var rootPath = scriptDirString.split('js')[0];
+        var rootPath = scriptDirString.split('firefly')[0];
+        var dataPath = rootPath+JAVA_TEST_DATA_PATH;
+
+        var jsonFiles = getJsonFiles(dataPath);
+        console.log(dataPath);
+
+        var imageHeader;
+        var expectedImagePt;
+        var expectedWorldPt;
+        var imagePt, worldPt;
+
+
+        for (let i=0; i<jsonFiles.length; i++){
+
+            it('this is to test:'+jsonFiles[i], function (){
+                var jsonStr =require(jsonFiles[i]);
+                imageHeader = jsonStr.header;
+                //console.log(imageHeader);
+                projectionJson['header'] = imageHeader;
+                projectionJson['coorindateSys'] = 'EQ_J2000';
+               // console.log(projectionJson);
+                var jsProjection = makeProjection(projectionJson);
+
+                if (jsProjection){
+                    console.log('the jsProject is:'+jsProjection.getProjectionName());
+                    var projectionName = jsProjection.getProjectionName();
+                    var maptype = imageHeader.maptype;
+                    expect(projTypes[projectionName]).to.equals(maptype);
+
+                }
+                else {
+                    console.log('jsProject is null');
+                }
+
+
+                imagePt = jsProjection.getImageCoords( imageHeader.crval1, imageHeader.crval2);//RA and DEC at the center of the image
+
+                //the expected value is achieved when the test is written.  If the Java code changes and
+                //the Assert is falling, the changes introduce the problem.
+                expectedImagePt = jsonStr['expectedImagePt'];//replace(/[=]/g, ':');
+
+                //console.log(image_pt);
+                expect( expectedImagePt.x.toFixed(precision)).to.equals(imagePt.x.toFixed(precision));
+                expect( expectedImagePt.y.toFixed(precision)).to.equals(imagePt.y.toFixed(precision));
+
+                // assert.equal(expectedImagePt ,image_pt );
+                expectedWorldPt = jsonStr['expectedWorldPt'];//.replace(/[=]/g, ':');
+
+                // console.log(expectedWorldPt);
+                //var expectedWorldPt = JSON.parse(expectedWorldPtStr);
+                worldPt = jsProjection.getWorldCoords(imagePt.x, imagePt.y);
+                expect( expectedWorldPt.x.toFixed(precision)).to.equals(worldPt.x.toFixed(precision));
+                expect(  expectedWorldPt.y.toFixed(precision)).to.equals(worldPt.y.toFixed(precision));
+
+
+
+            });
+        }
+
+    });
+
+});
+
diff --git a/src/firefly/test/edu/caltech/ipac/visualize/plot/projection/FitsHeaderToJson.java b/src/firefly/test/edu/caltech/ipac/visualize/plot/projection/FitsHeaderToJson.java
new file mode 100644
index 0000000000..7a7e17c831
--- /dev/null
+++ b/src/firefly/test/edu/caltech/ipac/visualize/plot/projection/FitsHeaderToJson.java
@@ -0,0 +1,212 @@
+package edu.caltech.ipac.visualize.plot.projection;
+
+import edu.caltech.ipac.visualize.plot.*;
+import nom.tam.fits.*;
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.lang.reflect.Field;
+
+/**
+ * Created by zhang on 6/21/16
+ *
+ */
+public class FitsHeaderToJson {
+
+    private static final String TEST_ROOT = "test"+ File.separatorChar;
+    private static final String PATH= TEST_ROOT+FitsHeaderToJson.class.getCanonicalName().replaceAll("\\.", "/")
+            .replace(FitsHeaderToJson.class.getSimpleName(), "") + File.separatorChar;
+
+
+    /**
+     * This is a good way to do it but don't figure out how to do it better.  It works for now.
+     * @param obj
+     * @return
+     */
+    private static int getDim(Object obj){
+
+        try{
+            //when this casting fail, it means the dimension is 1
+            double[][] dArray=(double[][]) obj;
+            return 2;
+        }
+        catch(Exception e){
+            return 1;
+        }
+    }
+
+    /**
+     * This method to convert one or two dimensional object/double array to JSONArray
+     * @param obj
+     * @return
+     */
+    private static JSONArray objetArrayToJsonSring(Object obj) {
+        JSONArray list2d = new JSONArray();
+        JSONArray list1d = new JSONArray();
+
+        if (getDim(obj)==2){
+            double[][] dArray=(double[][]) obj;
+            int len = dArray.length/2;
+            for (int i=0; i<len; i++) {
+                list1d.clear();
+                for (int j = 0; j < len; j++) {
+                    list1d.add(dArray[i][j]);
+                }
+                list2d.add(list1d);
+            }
+            return list2d;
+        }
+        else {
+            double[] dArray=(double[]) obj;
+            list1d.clear();
+
+            for (int j = 0; j < dArray.length; j++) {
+                list1d.add(dArray[j]);
+            }
+            return list1d;
+        }
+
+
+    }
+
+    /**
+     * This method put the ImageHeader to a JSONObject.  It
+     * @param obj
+     * @return
+     * @throws Exception
+     */
+    public static JSONObject  ImageHeaderToJson(Object obj)  throws Exception {
+
+        JSONObject jsonObj = new JSONObject();
+
+        Class<?> objClass = obj.getClass();
+        //array containing Field objects reflecting all the accessible public fields of the
+        //class or interface represented by this Class object
+        Field[] fields = objClass.getFields();
+        //process the field's name and value pair and save to JSONObject
+        for (Field field : fields) {
+            if (field == null) continue;
+            String name = field.getName();
+            Object value = field.get(obj);
+            if (value != null) {
+                if (value.getClass().isArray() ) {
+                      jsonObj.put(name, objetArrayToJsonSring(value));
+               }
+               else {
+                    if (name.equalsIgnoreCase("bunit")){
+
+                        jsonObj.put(name, value.toString());
+                    }
+                    else {
+                        jsonObj.put(name, value);
+                    }
+
+                }
+
+            }
+        }
+        return jsonObj;
+    }
+
+    private   static  ImageHeader getImageHeader(Fits fits)throws FitsException {
+        BasicHDU[] hdus = fits.read();
+
+        if (hdus == null){
+
+            throw new FitsException (" hdu is null");
+        }
+        Header header = hdus[0].getHeader();
+        ImageHeader imageHeader= new ImageHeader(header);
+
+        return imageHeader;
+    }
+
+
+    public static void writeToJson(String inputFitsFile) throws Exception {
+
+        Fits fits = new Fits(inputFitsFile);
+        JSONObject obj = new JSONObject();
+        String outJsonFile = inputFitsFile.substring(0, inputFitsFile.length()-5 ) + "Header.json";
+
+        obj.put("headerFileName", outJsonFile );
+        ImageHeader imageHeader = getImageHeader(fits);
+
+        //convert the ImageHeader object to jsonString
+        JSONObject imageHeaderObj = ImageHeaderToJson(imageHeader);
+        obj.put("header",imageHeaderObj);
+
+        /*the expected value is achieved when the test is written.  If the Java code changes and
+        the Assert is falling, the changes introduce the problem.
+        */
+        Projection projection = imageHeader.createProjection(CoordinateSys.EQ_J2000);
+
+        ProjectionPt imagePt = projection.getImageCoords( imageHeader.crval1, imageHeader.crval2);//RA and DEC at the center of the image
+        JSONObject imagePtJson = new JSONObject();
+        imagePtJson.put("x",imagePt.getX() );
+        imagePtJson.put("y",imagePt.getY() );
+        obj.put("expectedImagePt", imagePtJson);
+
+        WorldPt worldPt = projection.getWorldCoords(imagePt.getX(), imagePt.getY());
+        JSONObject worldPJson = new JSONObject();
+        worldPJson.put("x",worldPt.getX() );
+        worldPJson.put("y",worldPt.getY() );
+        obj.put("expectedImagePt", imagePtJson);
+        obj.put("expectedWorldPt",worldPJson);
+
+        try {
+            FileWriter file = new FileWriter(outJsonFile);
+            file.write(obj.toJSONString());
+            file.flush();
+            file.close();
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+    }
+
+
+
+    public static void main(String[] args) throws Exception {
+
+        if (args.length<1){
+            System.out.println("usage FitsHeaderToJson inputFile");
+        }
+
+
+
+        String path="/Users/zhang/lsstDev/testingData/projectionTestingData/";
+        String[] fNames = {
+                "1904-66_SFL.fits",                                      //SFL or GLS  SANSON-FLAMSTEED
+                "f3.fits",                                               //GNOMONIC
+                "DssImage-10.68470841.26902815.015.0poss2ukstu_red.fits", //PLATE
+                "GLM_01050+0000_mosaic_I2.fits",                        //CAR  CARTESIAN
+                "m51.car.fits",                                         //CAR  CARTESIAN
+                "field1.fits",                                          //SIN  ORTHOGRAPHIC
+                "m51.sin.fits",                                         //SIN  ORTHOGRAPHIC
+                             // "file7.fits",                                           //Not FITS format
+                             //"file7Downloaded.fits",
+                "SIP.fits",                                            //TAN--SIP  GNOMONIC
+                             //"lsstsample1.fits",                                   //CEA  CYLINDRICAL EQUAL AREA
+                "allsky.fits",                                        //AIT (ATF is deprecated)   AITOFF
+                "bird_2ha3-Booth.fits",                              //----  LINEAR
+                "NED_M31.fits",                                          //ARC  ZENITH EQUIDISTANT
+                "cong_12_smo.fits"                                    //ARC  ZENITH EQUIDISTANT
+        };
+
+        for (int i=0; i<fNames.length; i++) {
+            try {
+                writeToJson(path + fNames[i]);
+            }
+            catch (FitsException e) {
+                System.out.println("========ERROR=========="+fNames[i]+"===============");
+                e.printStackTrace();
+            }
+
+        }
+
+    }
+
+}
\ No newline at end of file
diff --git a/src/firefly/test/edu/caltech/ipac/visualize/plot/projection/ProjectionTest.java b/src/firefly/test/edu/caltech/ipac/visualize/plot/projection/ProjectionTest.java
new file mode 100644
index 0000000000..cdb42d70f4
--- /dev/null
+++ b/src/firefly/test/edu/caltech/ipac/visualize/plot/projection/ProjectionTest.java
@@ -0,0 +1,212 @@
+package edu.caltech.ipac.visualize.plot.projection;
+import edu.caltech.ipac.visualize.plot.*;
+import nom.tam.fits.*;
+import nom.tam.util.Cursor;
+import org.json.simple.JSONArray;
+import org.junit.*;
+
+import java.io.File;
+import java.lang.reflect.Field;
+import java.lang.reflect.Type;
+import java.net.URISyntaxException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+import org.json.simple.JSONObject;
+import org.json.simple.parser.JSONParser;
+import org.json.simple.parser.ParseException;
+/**
+ * Created by zhang on 6/15/16.
+ * We use the CoordinateSys defined in the FITS header, and also use the RA and DEC in the center of the image
+ * defined in the header
+ */
+public class ProjectionTest {
+
+    private  double delta = 0.0000000001;
+    private static final String TEST_DATA_ROOT = "firefly_test_data/";//edu/caltech/ipac/visualize/plot/projection/
+    private static final String TEST_DATA_PATH= TEST_DATA_ROOT+ProjectionTest.class.getCanonicalName().replaceAll("\\.", "/")
+      .replace(ProjectionTest.class.getSimpleName(), "") + File.separatorChar;
+
+    /**
+     * This method gets the .json files in the given directory
+     * @param path - the directory that has the testing data
+     * @return a String array of the testing files that include the abosolute path
+     */
+    private String[] getJsonFiles(String path){
+
+        File folder = new File(path);
+        ArrayList<String> fArray = new ArrayList<String>();
+        String[] fileNames = folder.list();
+
+        for (int i = 0; i < fileNames .length; i++) {
+            if (fileNames[i].endsWith(".json")) {
+                fArray.add(path+fileNames[i]);
+             }
+        }
+        return fArray.toArray(new String[0]);
+    }
+
+    /**
+     * Thie method pass a JSONObject that contains two fields into a Java HashMap
+     * @param jsonObject
+     * @return
+     */
+    private HashMap<String, Double> jsonObjectToMap(JSONObject jsonObject){
+        HashMap<String, Double> map = new HashMap<String, Double>();
+
+        String[] keys = (String[])  jsonObject.keySet().toArray(new String[0]);
+        for (int i=0; i<keys.length; i++){
+            map.put(keys[i], new Double((Double) jsonObject.get(keys[i])) );
+        }
+
+        return map;
+    }
+
+    /**
+     * This method convert a JSONArray which is one dimensional array to java double array
+     * @param jsonArray1d
+     * @return
+     */
+    private double[] jsonArray1dToDouble1d(JSONArray jsonArray1d){
+        double[] double1d = new double[jsonArray1d.size()];
+        for (int i=0; i<jsonArray1d.size(); i++){
+            double1d[i]=(double)jsonArray1d.get(i);
+        }
+        return double1d;
+    }
+
+    /**
+     * This method read the JSONObject which was converted by ImageHeader object and then convert it back to ImageHeader
+     * @param jsonObject
+     * @return
+     * @throws IllegalAccessException
+     */
+    private ImageHeader jsonObjectToImageHeader(JSONObject jsonObject) throws IllegalAccessException {
+
+        ImageHeader imageHeader = new ImageHeader();
+        Class<?> objClass =  imageHeader.getClass();
+
+        //array containing Field objects reflecting all the accessible public fields of the
+        //class or interface represented by this Class object
+        Field[] fields = objClass.getFields();
+        for (Field field : fields) {
+
+            if (field == null || field.toString().contains("final")) continue;
+            String name = field.getName();
+            Object value = jsonObject.get(name);
+
+            if (value != null) {
+                if (value instanceof JSONArray){ //test if the value is an array
+                    JSONArray jArray= (JSONArray) value;
+                    if (jArray.get(0) instanceof JSONArray) { //test if it is a two dimensional array
+                        int len = jArray.size();
+                        double[][] double2d = new double[len][((JSONArray) jArray.get(0)).size()];
+                        for (int i=0; i<len; i++){
+                            JSONArray a = (JSONArray) jArray.get(i);
+                            double2d[i]= jsonArray1dToDouble1d((JSONArray) jArray.get(i));
+                        }
+                        field.set(imageHeader, double2d);
+                    }
+                    else {
+                        double[] dArray = jsonArray1dToDouble1d(jArray);
+                        field.set(imageHeader, dArray);
+                    }
+                }
+                else { //none array
+                    Type type = field.getType();
+                    if (type.getTypeName().equalsIgnoreCase("int")) {
+                        if (value instanceof Long) {
+                            int v = ((Long) value).intValue();
+                            field.set(imageHeader, v);
+                        } else {
+                            field.set(imageHeader, value);
+                        }
+                    } else {
+                        field.set(imageHeader, value);
+                    }
+                }
+            }
+        }
+        return imageHeader;
+    }
+
+    /**
+     * This method validate the projection results
+     * @param jsonObject
+     * @throws FitsException
+     * @throws ProjectionException
+     * @throws IllegalAccessException
+     * @throws URISyntaxException
+     */
+    private void validate(JSONObject jsonObject) throws FitsException, ProjectionException, IllegalAccessException, URISyntaxException {
+
+        String jsonFileName = jsonObject.get("headerFileName").toString();
+
+
+        ImageHeader imageHeader = jsonObjectToImageHeader((JSONObject) jsonObject.get("header"));
+
+        Projection projection = imageHeader.createProjection(CoordinateSys.EQ_J2000);
+
+
+      try {
+          //Using the RA and DEC at the center of the image
+          ProjectionPt image_pt = projection.getImageCoords( imageHeader.crval1, imageHeader.crval2);
+
+          //the expected value is achieved when the test is written.  If the Java code changes and
+          //the Assert is falling, the changes introduce the problem.
+          Object  obj = jsonObject.get("expectedImagePt");
+          HashMap<String, Double>  expectedImagePtMap = jsonObjectToMap((JSONObject) obj);
+
+
+          Assert.assertEquals( expectedImagePtMap.get("x").doubleValue(),image_pt.getX(), delta  );
+          Assert.assertEquals( expectedImagePtMap.get("y").doubleValue(),image_pt.getY(), delta  );
+
+         /*the expected value is achieved when the test is written.  If the Java code changes and
+          the Assert is falling, the changes introduce the problem.
+         */
+          WorldPt world_pt = projection.getWorldCoords(image_pt.getX(), image_pt.getY());
+
+          obj = jsonObject.get("expectedWorldPt");
+          HashMap<String, Double> expectedWorldPtMap = jsonObjectToMap((JSONObject) obj);
+          Assert.assertEquals(expectedWorldPtMap.get("x").doubleValue(), world_pt.getX(), delta  );
+          Assert.assertEquals(expectedWorldPtMap.get("y").doubleValue(), world_pt.getY(), delta  );
+
+
+      }catch (Exception e) {
+           System.out.println(jsonFileName + " has exception");
+      }
+
+    }
+    @Test
+    public void testAllProjections() throws IOException, ParseException, FitsException, ProjectionException, IllegalAccessException, URISyntaxException {
+
+
+
+        //This is to run unit test under command line
+        String testTreePath = ProjectionTest.class.getProtectionDomain().getCodeSource().getLocation().getPath();
+        String  rootPath = testTreePath.split("firefly")[0];
+        String dataPath = rootPath+TEST_DATA_PATH;
+        String[] jsonHeaderFileNames =  getJsonFiles(dataPath);
+
+
+        JSONParser parser = new JSONParser();
+
+
+         for (int i=0; i<jsonHeaderFileNames.length; i++){
+            //System.out.println("\n The testing file is "+ jsonHeaderFileNames[i] +"\n");
+            Object obj = parser.parse(new FileReader(jsonHeaderFileNames[i]));
+
+            JSONObject jsonObject = (JSONObject) obj;
+            validate(jsonObject);
+
+        }
+
+    }
+}
+
+