R, 62 52 bytes

function(l)sum(combn(l,3,function(x)x[3]<x[1]+x[2]))

Try it online!

combn to the rescue!

combn generates all combinations of l of size n (in this case 3), optionally applying a function to each combination. In this case, we apply a triangle inequality test, and sum the resulting list to get the number out.

Stax, 8 7 bytes

Thanks to recursive for -1!

é═rê÷┐↨

Run and debug it at staxlang.xyz!

Unpacked (8 bytes) and explanation:

r3SFE+<+
r Reverse
 3S All length-3 combinations
 F For each combination:
 E Explode: [5,4,3] -> 3 4 5, with 3 atop the stack
 + Add the two shorter sides
 < Long side is shorter? 0 or 1
 + Add result to total

That's a neat trick. If you have a sequence of instructions that will always result in 0 or 1 and you need to count the items from an array that yield the truthy result at the end of your program, F..+ is a byte shorter than b:r<-scanr(:)[]t,c<-r,a+b>c]
f _=0


Try it online!

The function q=scanr(:)[] generates the list of suffixes. A lot of trouble comes from needing to consider including equal elements the right number of times.

52 bytes

q=scanr(:)[]
f l=sum[1 the third element.

Perl 6, 35 bytes

+*.combinations(3).flat.grep(*+*>*)

Try it online!

Explanation

It's a Whatever code, i. e. a concise notation for lambda functions (that works only in very simple cases). Each * is a placeholder for one argument. So we take the list of lengths (that appears at the first *), make all combinations of 3 elements (they always come out in the same order as in the original list, so that means the combinations are sorted too), flatten the list, and then take the list 3-by-3, and filter (grep) only those triplets that satisfy *+*>*, i. e. that the sum of the first two arguments is greater than the third. That gives all the triplets, and we finally count them with forcing numeric context with a +.

(Of course we need to test it only for the case of "sum of two smaller > the largest". If this holds, the other hold trivially, if this does not, the triplet does not denote correct triangle lengths and we don't need to look further.)

Excel VBA, 171 bytes

Sub z()
t=[A:A]
u=UBound(t)
For i=1To u-2
For j=i+1To u-1
For k=j+1To u
a=t(i,1):b=t(j,1):c=t(k,1)
If a+b>c And b+c>a And c+a>b Then r=r+1
Next:Next:Next
Debug.? r
End Sub

Input is in the range A:A of the active sheet. Output is to the immediate window.

Since this looks at every combination of every cell in a column that's 2²⁰ cells tall (which is nearly 2⁶⁰ combinations), this code is... not fast. You could make it much faster but at the expense of bytes.

Jelly, 9 bytes

œc3+>ƭ/€S

Try it online!

A monadic link taking a sorted list of integers as its argument and returning the number of triangles.

Alternative 9s:

œc3Ṫ€<§ƊS
œc3Ṫ<SƊ€S

Japt -x, 9 bytes

à3 ËÌÑ<Dx

Try it

à3 ®o <Zx

Try it

JavaScript (ES6), 63 bytes

f=([v,...a],p=[])=>v?(!p[2]&p[0]+p[1]>v)+f(a,p)+f(a,[...p,v]):0

Try it online!

Charcoal, 17 bytes

ＩΣ⭆θ⭆…θκ⭆…θμ›⁺νλι

Try it online! Link is to verbose version of code. Assumes sorted input. Explanation:

 θ Input array
 ⭆ Map over elements and join
 θ Input array
 … Truncated to length
 κ Outer index
 ⭆ Map over elements and join
 θ Input array
 … Truncated to length
 μ Inner index
 ⭆ Map over elements and join
 ν Innermost value
 ⁺ Plus
 λ Inner value
 › Is greater than
 ι Outer value
 Σ Take the digital sum
Ｉ Cast to string for implicit print

Octave / MATLAB, 33 bytes

@(x)sum(nchoosek(x,3)*[1;1;-1]>0)

Try it online!

Zsh, 66 bytes

for a;z=$y&&for b ($@:2+y++)for c ($@:3+z++)((t+=c<a+b))
<<<$t

Try it online!

Relatively straightforward, taking advantage of the sorted input, and incrementing in the for header (the increment happens once per parent loop).

for a;
 z=$y
 for b ($@:2+y++); # subarray starting at element after $a
 for c ($@:3+z++) # subarray starting at element after $b
 ((t+=c<a+b))
 

05AB1E, 12 10 bytes

Oh, dear. My first time using 05AB1E. This is (less) ugly (now). You have been warned.

3.Æʒy`Š+‹}g

Try it online! or test suite

A direct port of my Stax answer. Get all combinations of three entries and count those that could possibly form triangles. It's that counting part that really got me. I spend a load of bytes there. Bound to be some rookie mistake there.

3.Æʒ`Š+‹}g
3.Æ List of length-3 combinations
 ʒ }g Count truthy results under operation:
 `Š Push the long side, then the two shorter ones
 + Add the short ones
 ‹ Long side is shorter than this sum?

I'll be looking into shortening this. There's gotta be a way to drop the }.

Wolfram Language (Mathematica), 37 35 bytes

Tr@Boole[2#3<+##&@@@#~Subsets~3]&

Try it online!