Angular Testing: ¿How to test a custom implementation of TranslateLoader & MissingTranslationHandler?

I'm having trouble at testing two custom implementations of the ngx-translate TranslateLoader and MissingTranslationHandler abstract classes. The thing is that if I extend the abstract classes without decorators, I cannot inject them as services on the Testbed builder, and if I extend them with decorators, they cannot be used as intendend for the implementation of the ngx-translate library.

The error that appears in testing is related to the tested classes not having a decorator. I'm attaching the error message below. Is there any way to provide testing for these two classes in some way?

Error: Can't resolve all parameters for SvmTranslateLoader: (?).
at getUndecoratedInjectableFactory (http://localhost:9876/_karma_webpack_/node_modules/@angular/core/__ivy_ngcc__/fesm2015/core.js:17131:1)
at injectableDefOrInjectorDefFactory (http://localhost:9876/_karma_webpack_/node_modules/@angular/core/__ivy_ngcc__/fesm2015/core.js:17115:1)
at providerToFactory (http://localhost:9876/_karma_webpack_/node_modules/@angular/core/__ivy_ngcc__/fesm2015/core.js:17183:1)
at providerToRecord (http://localhost:9876/_karma_webpack_/node_modules/@angular/core/__ivy_ngcc__/fesm2015/core.js:17165:1)
at R3Injector.processProvider (http://localhost:9876/_karma_webpack_/node_modules/@angular/core/__ivy_ngcc__/fesm2015/core.js:16981:1)
at http://localhost:9876/_karma_webpack_/node_modules/@angular/core/__ivy_ngcc__/fesm2015/core.js:16960:1
at http://localhost:9876/_karma_webpack_/node_modules/@angular/core/__ivy_ngcc__/fesm2015/core.js:1400:1
at <Jasmine>
at deepForEach (http://localhost:9876/_karma_webpack_/node_modules/@angular/core/__ivy_ngcc__/fesm2015/core.js:1400:1)
at R3Injector.processInjectorType (http://localhost:9876/_karma_webpack_/node_modules/@angular/core/__ivy_ngcc__/fesm2015/core.js:16956:1)

I'm attaching the code of both custom classes, SvmTranslateLoader and SvmMissingTranslationHandler, plus my spec file. The former two work ok for all the other tests on my suite.

svm-translate.loader.spec.ts:

import { HttpClientTestingModule } from '@angular/common/http/testing';
import { inject, TestBed } from '@angular/core/testing';
import { SvmMissingTranslationHandler, SvmTranslateLoader } from './svm-translate.loader';
import { TranslateTestingModule } from '../../../mocks/translate-testing.module';

describe('SvmTranslate', () => {
    beforeEach(() => {
        TestBed.configureTestingModule({
            imports: [HttpClientTestingModule, TranslateTestingModule],
            providers: [SvmMissingTranslationHandler, SvmTranslateLoader, { provide: String, useValue: 'dummy' }]
        });
    });

    it('translateLoader should be created', inject([SvmTranslateLoader], (service: SvmTranslateLoader) => {
        expect(service).toBeTruthy();
    }));

    it('missingTranslationHandler should be created', inject([SvmMissingTranslationHandler], (service: SvmMissingTranslationHandler) => {
        expect(service).toBeTruthy();
    }));
});

SvmTranslateLoader:

export class SvmTranslateLoader implements TranslateLoader {
    constructor(private http: HttpClient, private prefix: string = 'i18n', private module: string, private suffix: string = '.json') {}

    /**
     * Gets the translations from the server
     */
    public getTranslation(lang: string): Observable<any> {
        const common = this.prefix + '/common_' + lang + this.suffix;
        const file = this.prefix + '/' + this.module + '_' + lang + this.suffix;

        const mergedObs = forkJoin(this.http.get(common), this.http.get(file));

        return mergedObs.pipe(
            map(d => {
                const merged = {};
                Object.assign(merged, d[0], d[1]);
                return merged;
            })
        );
    }
}

SvmMissingTranslationHandler:

export class SvmMissingTranslationHandler implements MissingTranslationHandler {
    private failNumber: number = 0;
    private originalValue: MissingTranslationHandlerParams = null;

    constructor() {}

    /**
     * Tries various methods to adjust case and retry the translations.
     * using this.failNumber because its  recursive call as they fail
     * I think there is a possible problem if two observbles are using
     * handler at the same time.
     * @param params
     */
    handle(params: MissingTranslationHandlerParams): any {
        if (this.failNumber === 0) {
            this.originalValue = _.clone(params); //clone and save original value
            this.failNumber = this.failNumber + 1;
            return params.translateService.instant(params.key.toLowerCase());
        } else if (this.failNumber === 1) {
            this.failNumber = this.failNumber + 1;
            return params.translateService.instant(params.key.toUpperCase());
            return params.translateService.instant(params.key.toUpperCase());
        } else if (this.failNumber === 2) {
            this.failNumber = this.failNumber + 1;
            return params.translateService.instant(this.titleCase(params.key));
        } else if (this.failNumber === 3) {
            this.failNumber = this.failNumber + 1;
            return params.translateService.instant(this.sentanceCase(params.key));
        } else if (this.failNumber === 4) {
            this.failNumber = this.failNumber + 1;
            return params.translateService.instant(params.key + ' ');
        } else if (this.failNumber === 5) {
            this.failNumber = this.failNumber + 1;
            return params.translateService.instant(params.key.trimRight());
        } else {
            // clone again original value and set to null to reuse before returning - RO-19/9/2019
            const returnValue = _.clone(this.originalValue);
            this.originalValue = null;
            // reset the fail number so the next word gets tried correctly
            this.failNumber = 0;
            // just returns english key if string is not in translation
            return returnValue.key;
        }
    }

    private titleCase(str: string): string {
        const splitStr = str.toLowerCase().split(' ');
        for (let i = 0; i < splitStr.length; i++) {
            // You do not need to check if i is larger than splitStr length, as your for does that for you
            // Assign it back to the array
            splitStr[i] = splitStr[i].charAt(0).toUpperCase() + splitStr[i].substring(1);
        }
        // Directly return the joined string
        return splitStr.join(' ');
    }

    private sentanceCase(str: string): string {
        const splitStr = str.toLowerCase().split(' ');
        for (let i = 0; i < splitStr.length; i++) {
            // You do not need to check if i is larger than splitStr length, as your for does that for you
            // Assign it back to the array
            if (i === 0) {
                splitStr[i] = splitStr[i].charAt(0).toUpperCase() + splitStr[i].substring(1);
            }
            if (i > 0) {
                splitStr[i] = splitStr[i].charAt(0).toLowerCase() + splitStr[i].substring(1);
            }
        }
        // Directly return the joined string
        return splitStr.join(' ');
    }
}