Skip to content
Snippets Groups Projects
Select Git revision
  • 9aea82817e8fe63338c88b565d690f25255d8de1
  • 3.9 default
  • develop
  • 6.0
  • 5.0
  • 4.0
  • scrutinizer-patch-4
  • scrutinizer-patch-3
  • scrutinizer-patch-2
  • scrutinizer-patch-1
  • 3.7
  • 3.8
  • 3.6
  • 3.9_backported
  • 3.8_backported
  • 3.7_backported
  • 3.5
  • 3.6_backported
  • 3.5_backported
  • 3.4
  • 3.3_backported
  • 6.0.4
  • 6.0.3
  • 5.0.7
  • 6.0.2
  • 6.0.1
  • 5.0.6
  • 6.0.0
  • 5.0.5
  • 6.0.0-rc
  • 5.0.4
  • 6.0.0-beta
  • 5.0.3
  • 4.0.6
  • 5.0.2
  • 5.0.1
  • 4.0.5
  • 5.0.0
  • 4.0.4
  • 5.0.0-rc2
  • 5.0.0-rc1
41 results

bank.lib.php

Blame
    • test_buy.js 16.02 KiB 
    import {determineBuyPrice} from '../js/buy.js';

/* globals QUnit */
QUnit.module('test_buy.js');
/* eslint-disable no-magic-numbers */

QUnit.test('find a buy price for a one-element forecast', (assert) => {
  assert.deepEqual(determineBuyPrice([100]), 100);
});

QUnit.test('find a buy price for a two-element descending forecast', (assert) => {
  assert.deepEqual(determineBuyPrice([100, 99]), 99);
});

QUnit.test('find a buy price for a two-element ascending forecast', (assert) => {
  assert.deepEqual(determineBuyPrice([100, 101]), 100);
});

QUnit.test('find a buy price for a three-element descending forecast', (assert) => {
  assert.deepEqual(determineBuyPrice([100, 99, 98]), 98);
});

QUnit.test('find a buy price for a three-element ascending forecast', (assert) => {
  assert.deepEqual(determineBuyPrice([100, 101, 102]), 100);
});

QUnit.test('find a buy price for a three-element dipping forecast', (assert) => {
  assert.deepEqual(determineBuyPrice([100, 99, 100]), 99);
});

QUnit.test('find a buy price for random forecast #0', (assert) => {
  assert.deepEqual(determineBuyPrice([144, 122, 121, 110, 91, 50, 60, 64, 102, 129, 146]), 50);
});

QUnit.test('find a buy price for random forecast #1', (assert) => {
  assert.deepEqual(determineBuyPrice([145, 143, 130, 70, 60, 53, 51, 127]), 51);
});

QUnit.test('find a buy price for random forecast #2', (assert) => {
  assert.deepEqual(determineBuyPrice([138, 104, 95, 108]), 95);
});

QUnit.test('find a buy price for random forecast #3', (assert) => {
  assert.deepEqual(determineBuyPrice([111, 80, 59, 73, 80, 97, 126, 134]), 59);
});

QUnit.test('find a buy price for random forecast #4', (assert) => {
  assert.deepEqual(determineBuyPrice([129, 117, 105, 57, 79, 101, 106, 110]), 57);
});

QUnit.test('find a buy price for random forecast #5', (assert) => {
  assert.deepEqual(determineBuyPrice([136, 135, 123, 86, 61, 60, 51, 53]), 51);
});

QUnit.test('find a buy price for random forecast #6', (assert) => {
  assert.deepEqual(determineBuyPrice([52, 55, 60, 78, 136]), 52);
});

QUnit.test('find a buy price for random forecast #7', (assert) => {
  assert.deepEqual(determineBuyPrice([60, 65, 71, 129]), 60);
});

QUnit.test('find a buy price for random forecast #8', (assert) => {
  assert.deepEqual(determineBuyPrice([137, 61, 52, 70, 89, 101, 134, 148]), 52);
});

QUnit.test('find a buy price for random forecast #9', (assert) => {
  assert.deepEqual(determineBuyPrice([144, 131, 120, 99, 51, 55, 65, 105, 109, 115, 116, 145]), 51);
});

    QUnit.test('find a buy price for random forecast #10', (assert) => {
  assert.deepEqual(determineBuyPrice([148, 146, 136, 112, 68, 52, 98, 115, 122]), 52);
});

QUnit.test('find a buy price for random forecast #11', (assert) => {
  assert.deepEqual(determineBuyPrice([138, 116, 99, 68, 67, 50, 63, 112]), 50);
});

QUnit.test('find a buy price for random forecast #12', (assert) => {
  assert.deepEqual(determineBuyPrice([110, 109, 82, 81, 79, 75, 69, 113, 115]), 69);
});

QUnit.test('find a buy price for random forecast #13', (assert) => {
  assert.deepEqual(determineBuyPrice([127, 91, 81, 53, 50, 57, 74, 83, 84, 101, 103, 133]), 50);
});

QUnit.test('find a buy price for random forecast #14', (assert) => {
  assert.deepEqual(determineBuyPrice([132, 113, 105, 71, 53, 55, 84, 88]), 53);
});

QUnit.test('find a buy price for random forecast #15', (assert) => {
  assert.deepEqual(determineBuyPrice([143, 134, 86, 67]), 67);
});

QUnit.test('find a buy price for random forecast #16', (assert) => {
  assert.deepEqual(determineBuyPrice([146, 134, 130, 120, 108, 66, 59, 83, 98, 115, 121, 129, 135, 147]), 59);
});

QUnit.test('find a buy price for random forecast #17', (assert) => {
  assert.deepEqual(determineBuyPrice([128, 127, 126, 102, 89, 62, 71]), 62);
});

QUnit.test('find a buy price for random forecast #18', (assert) => {
  assert.deepEqual(determineBuyPrice([86, 58, 75, 88, 89, 111, 127, 129]), 58);
});

QUnit.test('find a buy price for random forecast #19', (assert) => {
  assert.deepEqual(determineBuyPrice([134, 132, 129, 121, 113, 112, 96, 58, 101, 131, 148, 149]), 58);
});

QUnit.test('find a buy price for random forecast #20', (assert) => {
  assert.deepEqual(determineBuyPrice([147, 113, 98, 68, 55, 51]), 51);
});

QUnit.test('find a buy price for random forecast #21', (assert) => {
  assert.deepEqual(determineBuyPrice([138, 134, 98, 97, 93, 61, 60, 96, 130, 147]), 60);
});

QUnit.test('find a buy price for random forecast #22', (assert) => {
  assert.deepEqual(determineBuyPrice([137, 107, 92, 91, 64, 63, 55, 60, 74, 77, 86, 122, 134]), 55);
});

QUnit.test('find a buy price for random forecast #23', (assert) => {
  assert.deepEqual(determineBuyPrice([148, 133, 68, 55, 98, 117]), 55);
});

QUnit.test('find a buy price for random forecast #24', (assert) => {
  assert.deepEqual(determineBuyPrice([140, 125, 91, 64, 53, 65]), 53);
});

QUnit.test('find a buy price for random forecast #25', (assert) => {
  assert.deepEqual(determineBuyPrice([133, 127, 119, 115, 84, 65, 64, 71, 141, 142, 143]), 64);
});

QUnit.test('find a buy price for random forecast #26', (assert) => {
  assert.deepEqual(determineBuyPrice([116, 93, 50, 60, 106, 124, 137, 142]), 50);
});

QUnit.test('find a buy price for random forecast #27', (assert) => {
  assert.deepEqual(determineBuyPrice([142, 118, 105, 94, 87, 53, 88, 106, 138, 144, 149]), 53);
    });

QUnit.test('find a buy price for random forecast #28', (assert) => {
  assert.deepEqual(determineBuyPrice([138, 102, 74, 75, 96, 117, 134, 146]), 74);
});

QUnit.test('find a buy price for random forecast #29', (assert) => {
  assert.deepEqual(determineBuyPrice([144, 133, 100, 89, 88, 81, 58, 69, 75, 83, 91, 146]), 58);
});

QUnit.test('find a buy price for random forecast #30', (assert) => {
  assert.deepEqual(determineBuyPrice([140, 64, 83, 90, 96, 103, 130, 144]), 64);
});

QUnit.test('find a buy price for random forecast #31', (assert) => {
  assert.deepEqual(determineBuyPrice([136, 120, 103, 60, 92, 123, 124, 128, 130, 147]), 60);
});

QUnit.test('find a buy price for random forecast #32', (assert) => {
  assert.deepEqual(determineBuyPrice([139, 119, 88, 78, 76, 54, 112, 125, 128]), 54);
});

QUnit.test('find a buy price for random forecast #33', (assert) => {
  assert.deepEqual(determineBuyPrice([144, 81, 80, 64, 63, 97, 129, 131, 142, 144]), 63);
});

QUnit.test('find a buy price for random forecast #34', (assert) => {
  assert.deepEqual(determineBuyPrice([51, 85, 121, 137]), 51);
});

QUnit.test('find a buy price for random forecast #35', (assert) => {
  assert.deepEqual(determineBuyPrice([133, 120, 97, 94, 86, 83, 67, 59, 97, 99, 101, 130, 148]), 59);
});

QUnit.test('find a buy price for random forecast #36', (assert) => {
  assert.deepEqual(determineBuyPrice([55, 61, 103, 107, 131, 132]), 55);
});

QUnit.test('find a buy price for random forecast #37', (assert) => {
  assert.deepEqual(determineBuyPrice([95, 80, 79, 56, 54, 52, 51, 20, 54, 72, 115, 120, 129, 138]), 20);
});

QUnit.test('find a buy price for random forecast #38', (assert) => {
  assert.deepEqual(determineBuyPrice([134, 133, 132, 127, 115, 90, 87, 105, 107]), 87);
});

QUnit.test('find a buy price for random forecast #39', (assert) => {
  assert.deepEqual(determineBuyPrice([118, 117, 57, 67, 91, 120, 132]), 57);
});

QUnit.test('find a buy price for random forecast #40', (assert) => {
  assert.deepEqual(determineBuyPrice([77, 65, 54, 53, 76, 84, 109, 126, 147]), 53);
});

QUnit.test('find a buy price for random forecast #41', (assert) => {
  assert.deepEqual(determineBuyPrice([122, 110, 63, 80, 90, 117, 136, 138]), 63);
});

QUnit.test('find a buy price for random forecast #42', (assert) => {
  assert.deepEqual(determineBuyPrice([143, 139, 115, 84, 66, 116]), 66);
});

QUnit.test('find a buy price for random forecast #43', (assert) => {
  assert.deepEqual(determineBuyPrice([87, 73, 72, 71, 70, 62, 59, 69, 110]), 59);
});

QUnit.test('find a buy price for random forecast #44', (assert) => {
  assert.deepEqual(determineBuyPrice([56, 67, 81, 101, 104, 113]), 56);
});

    QUnit.test('find a buy price for random forecast #45', (assert) => {
  assert.deepEqual(determineBuyPrice([121, 98, 95, 92, 73, 63, 61, 129]), 61);
});

QUnit.test('find a buy price for random forecast #46', (assert) => {
  assert.deepEqual(determineBuyPrice([147, 99, 92, 94]), 92);
});

QUnit.test('find a buy price for random forecast #47', (assert) => {
  assert.deepEqual(determineBuyPrice([143, 139, 58, 69, 147]), 58);
});

QUnit.test('find a buy price for random forecast #48', (assert) => {
  assert.deepEqual(determineBuyPrice([51, 60, 61, 83, 108]), 51);
});

QUnit.test('find a buy price for random forecast #49', (assert) => {
  assert.deepEqual(determineBuyPrice([97, 87, 84, 57, 56, 54, 101, 143, 149]), 54);
});

QUnit.test('find a buy price for random forecast #50', (assert) => {
  assert.deepEqual(determineBuyPrice([137, 106, 105, 78]), 78);
});

QUnit.test('find a buy price for random forecast #51', (assert) => {
  assert.deepEqual(determineBuyPrice([98, 74, 67, 60, 54, 59, 63, 94, 119, 130, 136]), 54);
});

QUnit.test('find a buy price for random forecast #52', (assert) => {
  assert.deepEqual(determineBuyPrice([67, 99, 107, 143]), 67);
});

QUnit.test('find a buy price for random forecast #53', (assert) => {
  assert.deepEqual(determineBuyPrice([70, 50, 63, 71, 83]), 50);
});

QUnit.test('find a buy price for random forecast #54', (assert) => {
  assert.deepEqual(determineBuyPrice([136, 132, 125, 122, 83, 76, 68, 123, 137]), 68);
});

QUnit.test('find a buy price for random forecast #55', (assert) => {
  assert.deepEqual(determineBuyPrice([52, 97, 133, 144]), 52);
});

QUnit.test('find a buy price for random forecast #56', (assert) => {
  assert.deepEqual(determineBuyPrice([136, 129, 115, 94, 89, 87, 84, 61, 62, 63, 88, 117, 119, 137]), 61);
});

QUnit.test('find a buy price for random forecast #57', (assert) => {
  assert.deepEqual(determineBuyPrice([54, 70, 90, 106, 121, 125]), 54);
});

QUnit.test('find a buy price for random forecast #58', (assert) => {
  assert.deepEqual(determineBuyPrice([129, 69, 78, 88, 100, 104, 112]), 69);
});

QUnit.test('find a buy price for random forecast #59', (assert) => {
  assert.deepEqual(determineBuyPrice([139, 137, 123, 104, 90, 50, 55, 66, 70, 114]), 50);
});

QUnit.test('find a buy price for random forecast #60', (assert) => {
  assert.deepEqual(determineBuyPrice([111, 78, 63, 53, 70, 103, 127, 136]), 53);
});

QUnit.test('find a buy price for random forecast #61', (assert) => {
  assert.deepEqual(determineBuyPrice([147, 110, 103, 82, 76, 87, 90, 127]), 76);
});

QUnit.test('find a buy price for random forecast #62', (assert) => {
  assert.deepEqual(determineBuyPrice([121, 92, 79, 81, 86]), 79);
    });

QUnit.test('find a buy price for random forecast #63', (assert) => {
  assert.deepEqual(determineBuyPrice([52, 107, 129, 137]), 52);
});

QUnit.test('find a buy price for random forecast #64', (assert) => {
  assert.deepEqual(determineBuyPrice([114, 79, 78, 55, 71, 104, 106, 107, 139, 144]), 55);
});

QUnit.test('find a buy price for random forecast #65', (assert) => {
  assert.deepEqual(determineBuyPrice([146, 140, 134, 51, 59, 68, 69, 85, 106, 119]), 51);
});

QUnit.test('find a buy price for random forecast #66', (assert) => {
  assert.deepEqual(determineBuyPrice([65, 71, 123, 133, 141]), 65);
});

QUnit.test('find a buy price for random forecast #67', (assert) => {
  assert.deepEqual(determineBuyPrice([121, 82, 65, 60]), 60);
});

QUnit.test('find a buy price for random forecast #68', (assert) => {
  assert.deepEqual(determineBuyPrice([142, 136, 83, 71, 56, 55, 81, 104, 118, 137]), 55);
});

QUnit.test('find a buy price for random forecast #69', (assert) => {
  assert.deepEqual(determineBuyPrice([140, 134, 112, 90, 51, 59, 71, 109, 111, 124]), 51);
});

QUnit.test('find a buy price for random forecast #70', (assert) => {
  assert.deepEqual(determineBuyPrice([132, 88, 73, 68, 64, 56, 40, 55, 60]), 40);
});

QUnit.test('find a buy price for random forecast #71', (assert) => {
  assert.deepEqual(determineBuyPrice([112, 90, 89, 71, 59]), 59);
});

QUnit.test('find a buy price for random forecast #72', (assert) => {
  assert.deepEqual(determineBuyPrice([144, 138, 130, 115, 88, 78, 70, 95, 98, 100, 105, 110, 137]), 70);
});

QUnit.test('find a buy price for random forecast #73', (assert) => {
  assert.deepEqual(determineBuyPrice([126, 62, 70, 77, 86]), 62);
});

QUnit.test('find a buy price for random forecast #74', (assert) => {
  assert.deepEqual(determineBuyPrice([60, 65, 85, 117, 129, 148]), 60);
});

QUnit.test('find a buy price for random forecast #75', (assert) => {
  assert.deepEqual(determineBuyPrice([116, 92, 66, 60, 63, 94, 109, 113, 141]), 60);
});

QUnit.test('find a buy price for random forecast #76', (assert) => {
  assert.deepEqual(determineBuyPrice([140, 103, 89, 60, 87]), 60);
});

QUnit.test('find a buy price for random forecast #77', (assert) => {
  assert.deepEqual(determineBuyPrice([137, 134, 127, 96, 94, 81, 78, 75]), 75);
});

QUnit.test('find a buy price for random forecast #78', (assert) => {
  assert.deepEqual(determineBuyPrice([87, 64, 71, 72, 96, 115, 116, 135]), 64);
});

QUnit.test('find a buy price for random forecast #79', (assert) => {
  assert.deepEqual(determineBuyPrice([146, 144, 142, 129, 114, 60, 62, 91, 99, 117, 139, 169]), 60);
});

    QUnit.test('find a buy price for random forecast #80', (assert) => {
  assert.deepEqual(determineBuyPrice([143, 134, 130, 67, 143]), 67);
});

QUnit.test('find a buy price for random forecast #81', (assert) => {
  assert.deepEqual(determineBuyPrice([117, 96, 83, 60, 64, 67, 76, 81, 86]), 60);
});

QUnit.test('find a buy price for random forecast #82', (assert) => {
  assert.deepEqual(determineBuyPrice([130, 101, 98, 85, 78, 76, 57]), 57);
});

QUnit.test('find a buy price for random forecast #83', (assert) => {
  assert.deepEqual(determineBuyPrice([130, 122, 58, 56, 91, 108]), 56);
});

QUnit.test('find a buy price for random forecast #84', (assert) => {
  assert.deepEqual(determineBuyPrice([138, 84, 59, 102]), 59);
});

QUnit.test('find a buy price for random forecast #85', (assert) => {
  assert.deepEqual(determineBuyPrice([114, 62, 58, 57, 126, 130, 133]), 57);
});

QUnit.test('find a buy price for random forecast #86', (assert) => {
  assert.deepEqual(determineBuyPrice([127, 99, 96, 94, 93, 87, 79, 57, 84, 91, 118, 131, 133]), 57);
});

QUnit.test('find a buy price for random forecast #87', (assert) => {
  assert.deepEqual(determineBuyPrice([74, 91, 96, 102, 128]), 74);
});

QUnit.test('find a buy price for random forecast #88', (assert) => {
  assert.deepEqual(determineBuyPrice([149, 134, 118, 65, 64, 71, 95, 107, 118]), 64);
});

QUnit.test('find a buy price for random forecast #89', (assert) => {
  assert.deepEqual(determineBuyPrice([134, 127, 116, 107, 105, 98, 59, 61, 115]), 59);
});

QUnit.test('find a buy price for random forecast #90', (assert) => {
  assert.deepEqual(determineBuyPrice([73, 62, 60, 54, 76, 86, 105, 128]), 54);
});

QUnit.test('find a buy price for random forecast #91', (assert) => {
  assert.deepEqual(determineBuyPrice([143, 139, 128, 127, 115, 52, 109]), 52);
});

QUnit.test('find a buy price for random forecast #92', (assert) => {
  assert.deepEqual(determineBuyPrice([65, 64, 63, 78, 85, 92, 93, 143]), 63);
});

QUnit.test('find a buy price for random forecast #93', (assert) => {
  assert.deepEqual(determineBuyPrice([129, 126, 117, 96, 74, 72, 52, 74, 87]), 52);
});

QUnit.test('find a buy price for random forecast #94', (assert) => {
  assert.deepEqual(determineBuyPrice([138, 117, 112, 92, 57, 122]), 57);
});

QUnit.test('find a buy price for random forecast #95', (assert) => {
  assert.deepEqual(determineBuyPrice([122, 113, 101, 75]), 75);
});

QUnit.test('find a buy price for random forecast #96', (assert) => {
  assert.deepEqual(determineBuyPrice([67, 59, 79, 90, 102, 110, 113]), 59);
});

QUnit.test('find a buy price for random forecast #97', (assert) => {
  assert.deepEqual(determineBuyPrice([53, 82, 97, 108, 120]), 53);
    });

QUnit.test('find a buy price for random forecast #98', (assert) => {
  assert.deepEqual(determineBuyPrice([145, 137, 83, 82, 72, 71, 50, 56, 130]), 50);
});

QUnit.test('find a buy price for random forecast #99', (assert) => {
  assert.deepEqual(determineBuyPrice([51, 81, 101, 116, 127]), 51);
});